{"id":1290,"date":"2012-07-11T00:39:02","date_gmt":"2012-07-10T22:39:02","guid":{"rendered":"http:\/\/doanduyhai.wordpress.com\/?p=1290"},"modified":"2012-07-11T00:39:02","modified_gmt":"2012-07-10T22:39:02","slug":"java-8-lambda-in-details-part-i-closure-and-mutability","status":"publish","type":"post","link":"https:\/\/www.doanduyhai.com\/blog\/?p=1290","title":{"rendered":"Java 8 Lambda in details part I : Closure and Mutability"},"content":{"rendered":"

This article is the first one of a serie dedicated to Java 8 Lambda expressions. The purpose is not to introduce the main concepts of lambda expressions, many blogs over there do it very well. The idea is to
\nshed some light on tricky details and side effects. If you’re not familiar with the new lambda-related features in Java 8, I strongly advise to look at the following article http:\/\/cr.openjdk.java.net\/~briangoetz\/lambda\/lambda-state-4.html<\/a><\/p>\n

Today we’ll look at the mutability issue<\/strong> when dealing with closures.<\/p>\n

<\/p>\n

DISCLAIMER: all the details exposed in this post were observed related to the JDK 8 demo version as of July 10th 2012<\/font>. Since the JDK is still in beta, some assertions may not hold in future<\/strong>\n<\/p><\/blockquote>\n

Please note that all the example code in this post can be found on my GitHub repository https:\/\/github.com\/doanduyhai\/Java8_Lambda_In_Details<\/a><\/p><\/blockquote>\n

I Abstract<\/h1>\n

When dealing with closures, we should be aware of the fact that the closure code body can have reference on objects of its enclosing class. This leads to 2 major implications:<\/p>\n

    \n
  1. The enclosing object instance referred to by the closure code (with the this<\/strong> keyword or any implicit unqualified reference to its fields<\/strong>) cannot be garbaged by the GC even though it hasn’t any direct reference left in the heap<\/li>\n
  2. If the referred object is mutable, we may encounters some side effects<\/li>\n<\/ol>\n

    In the rest of this post, we will focus on the second point.
    \n <\/p>\n

    II Capture of variable in closure<\/h1>\n

    Let’s consider the following code<\/p>\n

    \npublic interface VariableCaptureInClosureSAM\n{\n\tMutableObject retrieveMutable();\n}\n\npublic class MutableObject\n{\n\tprivate String content = &quot;default_content&quot;;\n\n\tpublic String getContent()\n\t{\n\t\treturn content;\n\t}\n\n\tpublic void setContent(String content)\n\t{\n\t\tthis.content = content;\n\t}\n}\n\npublic class VariableCaptureInClosure\n{\n\tfinal public MutableObject mutable = new MutableObject();\n\n\tpublic VariableCaptureInClosureSAM createClosure()\n\t{\n\t\tVariableCaptureInClosureSAM lambda = ()-&gt;\n\t\t{\t\n\t\t\treturn this.mutable;\n\t\t};\n\n\t\treturn lambda;\n\t}\n\n\tpublic void addToMutableContent(String toAdd)\n\t{\n\t\tthis.mutable.setContent(this.mutable.getContent() + &quot; &quot; + toAdd);\n\t}\n\n\tpublic void printMutableContent(String stage)\n\t{\n\t\tSystem.out.println(&quot;nCurrent VariableCaptureInClosure.mutable reference : &quot; + this.mutable.toString());\n\t\tSystem.out.println(&quot;At stage &quot; + stage + &quot;, current VariableCaptureInClosure.mutable content = &quot; + this.mutable.getContent());\n\n\t}\n\n\tpublic static void main(String[] args)\n\t{\n\t\tVariableCaptureInClosure variableCapture = new VariableCaptureInClosure();\n\t\tVariableCaptureInClosureSAM lambda = variableCapture.createClosure();\n\n\t\tMutableObject mutableFromClosure = lambda.retrieveMutable();\n\t\tSystem.out.println(&quot;nmutableFromClosureBeforeMutation reference : &quot; + mutableFromClosure.toString());\n\t\tSystem.out.println(&quot;mutableFromClosureBeforeMutation content = &quot; + mutableFromClosure.getContent());\n\n\t\tvariableCapture.printMutableContent(&quot;BEFORE MUTATION&quot;);\n\t\tvariableCapture.addToMutableContent(&quot;mutable&quot;);\n\t\tvariableCapture.printMutableContent(&quot;AFTER MUTATION&quot;);\n\n\t\tSystem.out.println(&quot;nmutableFromClosureAfterMutation reference : &quot; + mutableFromClosure.toString());\n\t\tSystem.out.println(&quot;mutableFromClosureAfterMutation content = &quot; + mutableFromClosure.getContent());\n\t\tSystem.out.println(&quot;&quot;);\n\t}\n}\n<\/pre>\n
     First we declare a SAM (S<\/strong>ingle M<\/strong>ethod I<\/strong>nterface) with the abstract MutableObject<\/strong> retrieveMutable()<\/em> method.<\/p>\n
     The MutableObject<\/strong> is a plain POJO with a String field and a setter to change its value and hence make it mutable. Please note that this MutableObject<\/strong> is initialized with “default_content<\/strong>” as content.<\/p>\n
     In the VariableCaptureInClosure<\/strong> class, we define the method createClosure()<\/em> whose purpose is to return a lambda expression that captures the final<\/strong> mutable<\/em> field (line 25<\/strong>)<\/p>\n
     In the main()<\/em> method, we start by retrieving the lambda expression (line 50<\/strong>) then we get a reference to the mutable object (line 52<\/strong>)<\/p>\n
     We then display the reference on this mutable object and its content:<\/p>\n
    \nmutableFromClosureBeforeMutation reference : fr.doan.lambda.mutability.MutableObject@8c5a4f<\/strong>
    \nmutableFromClosureBeforeMutation content = default_content\n<\/p><\/blockquote>\n
     Next, we get the reference of the mutable<\/em> object from the VariableCaptureInClosure<\/strong> instance and display its content (lines 53-54<\/strong>):<\/p>\n
    Current VariableCaptureInClosure.mutable reference : fr.doan.lambda.mutability.MutableObject@8c5a4f<\/strong>
    \nAt stage BEFORE MUTATION, current VariableCaptureInClosure.mutable content = default_content\n<\/p><\/blockquote>\n
     At this stage, we can clearly see that both instances of MutableObject<\/strong> class, the one returned by the lambda expression and the one of the VariableCaptureInClosure<\/strong> instance, are identical, not surprising.<\/p>\n
     Now the idea is to change the content of this mutable object by calling the method addToMutableContent(String toAdd)<\/em> and print out the result.<\/p>\n
    Current VariableCaptureInClosure.mutable reference : fr.doan.lambda.mutability.MutableObject@8c5a4f<\/strong>
    \nAt stage AFTER MUTATION, current VariableCaptureInClosure.mutable content = default_content mutable<\/strong><\/p><\/blockquote>\n
    The content has been actually changed. Now if we check again the MutableObject<\/strong> instance from the closure, its content has been also changed and it’s expected.<\/p>\n
    mutableFromClosureAfterMutation reference : fr.doan.lambda.mutability.MutableObject@8c5a4f<\/strong>
    \nmutableFromClosureAfterMutation content = default_content mutable<\/strong><\/p><\/blockquote>\n
    This small example shows us that a lambda expression can keep a reference on a object from its enclosing class (but it’s not exactly<\/strong> that, we’ll see later in the next chapter). If the object is mutable, changes can come both from the owning class and the lambda expression.<\/p>\n
     The new collection API enhancement in Java 8 provides some usefull method to work in parallel on collection. You should take care about your object mutability if you are working on an multi-threaded environment since it may lead to serious side effects. <\/p>\n
     Please notice that the mutable field being declared as final (line 23<\/strong>) does not help it being less mutable since mutability<\/strong> and final variable<\/strong> are two distinct concepts (most people are still confused about it)<\/p>\n
     The above code example can be found on GitHub at https:\/\/github.com\/doanduyhai\/Java8_Lambda_In_Details<\/a>. Just execute the VariableCaptureInClosure.bat<\/strong>(VariableCaptureInClosure.sh<\/strong>) script<\/p><\/blockquote>\n
     <\/p>\n
    III Non final variable<\/h1>\n
    In the following example, we make the previous mutable<\/em> field non final.<\/p>\n
    \npublic class NonFinalVariableCaptureInClosure\n{\n\tpublic MutableObject mutable = new MutableObject();\n\n\tpublic VariableCaptureInClosureSAM createClosure()\n\t{\n\t\tVariableCaptureInClosureSAM lambda = ()-&gt;\n\t\t{\n\t\t\treturn this.mutable;\n\t\t};\n\t\treturn lambda;\n\t}\n\n\tpublic void addToMutableContent(String toAdd)\n\t{\n\t\tthis.mutable.setContent(this.mutable.getContent() + &quot; &quot; + toAdd);\n\t}\n\n\tpublic void printMutableContent(String stage)\n\t{\n\t\tSystem.out.println(&quot;nCurrent VariableCaptureInClosure.mutable reference : &quot; + this.mutable.toString());\n\t\tSystem.out.println(&quot;At stage &quot; + stage + &quot;, current VariableCaptureInClosure.mutable content = &quot; + this.mutable.getContent());\n\n\t}\n\n\tpublic static void main(String[] args)\n\t{\n\t\tNonFinalVariableCaptureInClosure variableCapture = new NonFinalVariableCaptureInClosure();\n\t\tVariableCaptureInClosureSAM lambda = variableCapture.createClosure();\n\n\t\tMutableObject mutableFromClosureBeforeRefChange = lambda.retrieveMutable();\n\t\tSystem.out.println(&quot;nmutableFromClosureBeforeRefChange reference : &quot; + mutableFromClosureBeforeRefChange.toString());\n\t\tSystem.out.println(&quot;mutableFromClosureBeforeRefChange content = &quot; + mutableFromClosureBeforeRefChange.getContent());\n\n\t\tMutableObject newMutable = new MutableObject();\n\t\tnewMutable.setContent(&quot;new_content&quot;);\n\t\tvariableCapture.mutable = newMutable;\n\n\t\tMutableObject mutableFromClosureAfterRefChange = lambda.retrieveMutable();\n\n\t\tSystem.out.println(&quot;nmutableFromClosureAfterRefChange reference : &quot; + mutableFromClosureAfterRefChange.toString());\n\t\tSystem.out.println(&quot;mutableFromClosureAfterRefChange content = &quot; + mutableFromClosureAfterRefChange.getContent());\n\t\tSystem.out.println(&quot;&quot;);\n\t}\n}\n<\/pre>\n
     The code is quite straightforward. We create a new MutableObject<\/strong> and assign it to the mutable<\/em> field of the NonFinalVariableCaptureInClosure<\/strong> instance (lines 35-37<\/strong>). The output shows:<\/p>\n
    \nmutableFromClosureBeforeRefChange reference : fr.doan.lambda.mutability.MutableObject@14f7121<\/strong>
    \nmutableFromClosureBeforeRefChange content = default_content<\/strong><\/p>\n
    mutableFromClosureAfterRefChange reference : fr.doan.lambda.mutability.MutableObject@8c5a4f<\/strong>
    \nmutableFromClosureAfterRefChange content = new_content<\/strong><\/p><\/blockquote>\n
     This result is more surprising. We expect that the second call to lambda.retrieveMutable()<\/em> (line 39<\/strong>) will return us the old MutableObject<\/strong> instance (14f7121<\/strong>) but it’s not the case.<\/p>\n
     What happends under the hood is that the lambda expression captures its enclosing context by keeping a reference on the NonFinalVariableCaptureInClosure<\/strong> instance via the this<\/strong> keyword in return this<\/strong>.mutable;<\/em> (line 9<\/strong>) and not a reference to the MutableObject<\/strong> itself…<\/font><\/p>\n
    So the second call to lambda.retrieveMutable()<\/em> returns the new instance of MutableObject<\/strong> we just create and assign to the NonFinalVariableCaptureInClosure<\/strong> object.<\/p>\n
     The above code example can be found on GitHub at https:\/\/github.com\/doanduyhai\/Java8_Lambda_In_Details<\/a>. Just execute the NonFinalVariableCaptureInClosure.bat<\/strong>(NonFinalVariableCaptureInClosure.sh<\/strong>) script<\/p><\/blockquote>\n
     To be continued …<\/p>\n
     
    \n <\/p>\n","protected":false},"excerpt":{"rendered":"
    This article is the first one of a serie dedicated to Java 8 Lambda expressions. The purpose is not to introduce the main concepts of lambda expressions, many blogs over there do it very well. The idea is to shed…
    Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[6,8],"tags":[],"_links":{"self":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1290"}],"collection":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1290"}],"version-history":[{"count":0,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1290\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1290"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1290"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1290"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}