There is a lot to like about the threading model in Java. It's easy to make threads, it's decently fast, and it's stable. One thing that I wished<\/b> they'd put into the JVM - or at least into javac<\/tt> like all the other 1.5\/1.6 compiler 'hacks', is the idea that synchronization on a setter can be controlled by the instance variable itself. What I'm asking for is an automatic way to have javac<\/tt> create thread-safe setters and getters by simply naming the ivar.<\/p>\n
The most obvious way of making a thread-safe setter is this:<\/p>\n
\n <\/span>\/**\n * This is the standard setter for the temperature\n * of this instance.\n *\/<\/span>\n <\/span>public<\/span> <\/span>synchronized<\/span> <\/span>void<\/span> <\/span>setTemp<\/span>(<\/span>double<\/span> <\/span>aTemp<\/span>)\n {\n <\/span>_temp<\/span> = <\/span>aTemp<\/span>;\n }<\/span><\/code><\/pre>\nbut the downside is that this means that if this instance is in a highly threaded environment, or there are other methods that take a significant amount of time to process, the ability to 'set' the temperature is dependent on the other synchronized<\/tt> methods on this class.<\/p>\n
Sure, you can make an object to lock on and it might look like this:<\/p>\n
\n <\/span>private<\/span> <\/span>double<\/span> <\/span>_temp<\/span> = <\/span>0<\/span>;\n <\/span>private<\/span> <\/span>String<\/span> <\/span>_tempLock<\/span> = <\/span>\"TempLock\"<\/span>;\n \n <\/span>\/**\n * This is the setter for the temperature uses an\n * additional ivar - a String, to protect multiple\n * threads changing the value at once.\n *\/<\/span>\n <\/span>public<\/span> <\/span>void<\/span> <\/span>setTemp<\/span>(<\/span>double<\/span> <\/span>aTemp<\/span>)\n {\n <\/span>synchronized<\/span> (<\/span>_tempLock<\/span>) {\n <\/span>_temp<\/span> = <\/span>aTemp<\/span>;\n }\n }<\/span><\/code><\/pre>\nbut then you have all these extra<\/i> ivars that you have no real need for and no need to really put into the setter other than as a thread-safety mechanism.<\/p>\n
Some will argue that if I had used a Double<\/tt> and not a double<\/tt> I could synchronize on the ivar itself. But it's not really safe doing that. You'd have to be careful of the null<\/tt> value and then what if you changed the reference within the synchronized<\/tt> block - you'd no longer be protected. No, there needs to be the ivar itself - allowing null<\/tt>, and then some mechanism to ensure thread safety on a more finer-grained level than locking the entire instance.<\/p>\n
They need to have something that does the obvious<\/b> things for an ivar of a given type. You want to save typing? Make something like this:<\/p>\n\n <\/span>\/**\n * These create the setter and getter for the ivar\n * '_temp' because the need to lock is implied\n * on the setter and typically unnecessary on the\n * getter (unless it's a long).\n *\/<\/span>\n <\/span>public<\/span> <\/span>threadsafe<\/span> <\/span>setTemp<\/span>(<\/span>double<\/span> <\/span>aTemp<\/span>) : <\/span>private<\/span> <\/span>double<\/span> <\/span>_temp<\/span>;\n <\/span>public<\/span> <\/span>threadsafe<\/span> <\/span>getTemp<\/span>() : <\/span>private<\/span> <\/span>double<\/span> <\/span>_temp<\/span>;\n \n <\/span>\/**\n * These versions would create 'protected' versions\n * of the getter and setter methods.\n *\/<\/span>\n <\/span>protected<\/span> <\/span>threadsafe<\/span> <\/span>setTemp<\/span>(<\/span>double<\/span> <\/span>aTemp<\/span>) : <\/span>private<\/span> <\/span>_temp<\/span>;\n <\/span>protected<\/span> <\/span>threadsafe<\/span> <\/span>getTemp<\/span>() : <\/span>private<\/span> <\/span>_temp<\/span>;\n\n <\/span>\/**\n * This creates both setter and getter for the ivar\n * '_temp' because the structure to create the two\n * is clear from this information alone.\n *\/<\/span>\n <\/span>public<\/span> <\/span>threadsafe accessors<\/span> <\/span>Temp<\/span> : <\/span>private<\/span> <\/span>double<\/span> <\/span>_temp<\/span>;\n<\/span><\/code><\/pre>\nThe information to build the code for the setter and getter is clearly specified in the above examples. In the first set, the ivar _temp<\/tt> is clearly private, a double<\/tt> and the names of the methods to build are clear. There's even the argument type - which is really redundant, if you think about it.<\/p>\n
A possibly even simpler solution would be to combine the definition of the ivar and the scope of the setter and getter in one statement - like the last example. That way, you would know the ivar's name, type, scope, and then the scope of the setter and getter. You could even allow one to use a PropertyChange system with listener registration, etc. This is not that hard, and I've used it in tons<\/b> of classes. The clutter it'd save would be far far more<\/i> than the collapsed<\/i> for-loop.<\/p>\n
Anyway, today I did a lot of the 'mutex' variables because I needed to remove as many synchronized<\/tt> methods as possible on a class I was working with. Virtually every one of them was a setter, and it was annoying to think that they made a goofy collapsed<\/i> for-loop in 1.5, but they left this little nugget out.<\/p>\n
Amazing. I think it shows to me that defensive programming is not heavily exercised by the Java Developers. Otherwise, they too, would be sick of making thread-safe but not lock greedy<\/i> accessor methods.<\/p>\n","protected":false},"excerpt":{"rendered":"
There is a lot to like about the threading model in Java. It’s easy to make threads, it’s decently fast, and it’s stable. One thing that I wished they’d put into the JVM – or at least into javac like all the other 1.5\/1.6 compiler ‘hacks’, is the idea that synchronization on a setter can […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[],"class_list":["post-263","post","type-post","status-publish","format-standard","hentry","category-coding"],"_links":{"self":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/posts\/263","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/comments?post=263"}],"version-history":[{"count":0,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/posts\/263\/revisions"}],"wp:attachment":[{"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/media?parent=263"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/categories?post=263"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/bobbeaty.com\/wp\/wp-json\/wp\/v2\/tags?post=263"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}