I’ve seen many developers struggling with subtle mutability issues in Java. This article will expose the major gotchas of object immutability.<\/p>\n
<\/p>\n
An object is said to be “immutable<\/strong>” when, after its initialization (object creation), its internal state does not change<\/strong>.<\/p>\n The definition looks quite simple and straightforward but the “its internal state does not change” part is very hard to obtain.<\/p>\n One simple example of immutable object in Java is the String class. One created, the text content of a String instance can never change. Everytime you call a helper method on this String instance (concat(), subString(), toLowerCase()…<\/em>), a new instance of String is returned, the original String instance remains unchanged.<\/p>\n The above code will display as output:<\/p>\n <\/p>\n The first idea to make an object immutable is to declare all its attributes “private<\/strong>” and to remove all setters<\/strong>. But without setters we have to find a way to initialize these private attributes. One solution could be declaring them as constructor arguments. During the object initialization, we provide all the attributes. After the initialization, since the attribute are privates they cannot be accessed from the outside, thus guaranting immutabitily.<\/p>\n Below an example:<\/p>\n The above code shows an ImmutableByEncapsulation<\/strong> class with a constructor accepting a List of String (default constructor is made private to force initialization with List of String<\/em>).<\/p>\n Once created, the internal items list cannot be accessed from the outside so cannot be modified.<\/p>\n Indeed there is a big flaw<\/strong> in this example. Let’s check the below code:<\/p>\n The previous design is completely broken because the main code still have a reference to the items<\/em> list passed as constructor argument. The internal items<\/em> list can be modified outside of ImmutableByEncapsulation<\/strong>.<\/p>\n To fix this, we need to make a copy of the items<\/em> list passed as constructor argument.<\/p>\n This way, any modification made to the items<\/em> list after ImmutableByEncapsulation<\/strong> initialization will not impact its internal state.<\/p>\n <\/p>\n The above solution makes the ImmutableByEncapsulation<\/strong> immutable because the list of items<\/em> is of type String, which is immutable. Had we changed it to another non-immutable<\/strong> type, it wouldn’t work.<\/p>\n Let’s turn the list of String into a list of Furniture<\/strong>, a custom type:<\/p>\n This is the immutability cascade issue. To make an object really immutable, all its internal object graph should be immutable.<\/p>\n Please note that it was easy to make our Furniture<\/strong> class immutable. All we need to do is to remove the setter methods. Since the String and primitive types are immutable, the class would be immutable after its initialization. For real life use cases it is sometimes required that the immutable object exposes its internal state as read-only value. In this case, two possible solutions:<\/p>\n Let’s see an example.<\/p>\n In the above code, we can see that there is a double level of cloning. <\/p>\n First in the constructor, a new list is created in which we put all the clones of MutableObject. The list is cloned (new ArrayList<\/strong>) and each element inside the list is also cloned. <\/p>\n This pattern ensures that no reference of the internal state (reference on items<\/em> attribute or on each MutableObject<\/strong> in the items<\/em> list) leaks outside of the class.<\/p>\n The same pattern is applied to the getter getItems()<\/em> for immutability. Even if you have spent hours designing a perfectly immutable class (by implementing clone()<\/em> for all the internal components). There is still one possibility to ruin your hard work. <\/p>\n How ? <\/p>\n Simply by extending your class and re-defining the safe getters and removing object cloning pattern!<\/strong><\/p>\n To really enforce strict immutability, you need to declare your class as final<\/strong> so it cannot be extended.<\/p>\n <\/p>\n After these few examples, we can see that any time a reference to an internal component is accessible from outside of the object (constructor argument, getters or simple method returned values<\/em>) there is a risk of modification and the immutability can be broken, unless the return values are themselves immutable.<\/strong><\/p>\n From this observation, some rules of thumb can be drawn. To make an object immutable<\/p>\n Neither of the above conditions is simple. Making a class truly immutable is hard, making the internal component graph immutable is even harder. The cloning solution is not a piece of cake either. Redefining the clone()<\/em> method in a proper manner to implement deep copy<\/strong> is a dawnting task, especially when you have a complex object graph.<\/p>\n There are some articles over there on the Web with object serialization as a solution for object deep copy but the impact on performance is huge<\/strong>. Object serialization can be sometimes hundred times slower than manual clone()<\/em> redefinition.<\/p>\n At the bottom line, object immutability is a quite complex subject. Immutability in a “classical” Java application is usually not really an issue.<\/p>\n Immutability becomes useful and interesting when dealing with multi-threaded applications because immutable objects are by nature thread-safe<\/strong> and save from synchronization headache.<\/p>\n I’ve seen many developers struggling with subtle mutability issues in Java. This article will expose the major gotchas of object immutability.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[22,6],"tags":[],"_links":{"self":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1153"}],"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=1153"}],"version-history":[{"count":0,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/1153\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1153"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1153"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.doanduyhai.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1153"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n\nString myString ="TEST";\n\nString subString = myString.toLowerCase();\n\nSystem.out.println("myString == subString ? "+ (myString == subString));\n\n<\/pre>\n
myString == subString ? false<\/pre>\n
II Immutability and encapsulation<\/h1>\n
\npublic class ImmutableByEncapsulation\n{\n\tprivate List<String> items;\n\n\tpublic ImmutableByEncapsulation(List<String> items) {\n\t\tthis.items = items;\n\t}\n\n\t@SuppressWarnings("unused")\n\tprivate ImmutableByEncapsulation() {\n\t\tsuper();\n\t}\n\n\tpublic String getItemByPosition(int position)\n\t{\n\t\tif (position >= 0 && position < this.items.size())\n\t\t{\n\t\t\treturn this.items.get(position);\n\t\t}\n\n\t\treturn null;\n\t}\n}\n<\/pre>\n\n\nList<String> items = new ArrayList<String>();\n\nitems.add("table");\nitems.add("chair");\nitems.add("desk");\n\nImmutableByEncapsulation ob = new ImmutableByEncapsulation(items);\n\n...\nob.getItemByPosition(2);\n...\n\nitems.add("sofa"); \/\/ Immutability broken !!!\n...\n<\/pre>\n
\npublic class ImmutableByEncapsulation\n{\n\tprivate List<String> items;\n\n\tpublic ImmutableByEncapsulation(List<String> items) {\n\t\tthis.items = new ArrayList<String>(items);\n\t}\n\t...\n}\t\n<\/pre>\nIII Immutability and object graph<\/h1>\n
\npublic class Furniture\n{\n\tprivate String type;\n\tprivate int quantity;\n\n\tpublic Furniture(String type, int quantity) {\n\t\tsuper();\n\t\tthis.type = type;\n\t\tthis.quantity = quantity;\n\t}\n\n\tpublic String getType() {return type;}\n\n\tpublic void setType(String type) {this.type = type;}\n\n\tpublic int getQuantity() {return quantity;}\n\n\tpublic void setQuantity(int quantity) {\tthis.quantity = quantity;}\t\n}\n\npublic class ImmutableByEncapsulation\n{\n\tprivate List<Furniture> items;\n\n\tpublic ImmutableByEncapsulation(List<Furniture> items) {\n\t\tthis.items = new ArrayList<Furniture>(items);\n\t}\n\t...\t\n}\n\n...\n...\nList<Furniture> items = new ArrayList<Furniture>();\n\nFurniture table = new Furniture("table",2);\nFurniture chair = new Furniture("chair",10);\nFurniture sofa = new Furniture("sofa",1);\n\nitems.add(table);\nitems.add(chair);\nitems.add(sofa);\n\nImmutableByEncapsulation ob = new ImmutableByEncapsulation(items);\n\n...\nob.getItemByPosition(2);\n...\n\nchair.setQuantity(100) \/\/ Immutability broken !!\n...\n<\/pre>\n
\n <\/p>\nIV Immutability and cloning<\/h1>\n
\n
\npublic class ImmutableByCloning\n{\n\tprivate List<MutableObject> items;\n\n\tpublic ImmutableByCloning(List<MutableObject> items) {\n\t\tthis.items = new ArrayList<MutableObject>();\n\t\tfor (MutableObject mutableItem : items)\n\t\t{\n\t\t\tthis.items.add(mutableItem.clone());\n\t\t}\n\t}\n\n\t@SuppressWarnings("unused")\n\tprivate ImmutableByCloning() {}\n\n\tpublic List<MutableObject> getItems()\n\t{\n\n\t\tList<MutableObject> returnedItems = new ArrayList<MutableObject>();\n\t\tfor (MutableObject mutableItem : this.items)\n\t\t{\n\t\t\treturnedItems.add(mutableItem.clone());\n\t\t}\n\n\t\treturn returnedItems;\n\t}\n}\n<\/pre>\n
\n <\/p>\nV Protect your immutables !<\/h1>\n
VI Conclusion<\/h1>\n
\n
\n
\n <\/p>\n","protected":false},"excerpt":{"rendered":"