Alex Miller

It's an opportune moment to mention that the Call for Presentations for Strange Loop 2010 is still open, so if you submitted a talk at JavaOne, perhaps it might be a good fit at Strange Loop.

The Strange Loop conference is a technology-agnostic, future-seeking conference about alternative languages, alternative database technologies, concurrency, distributed systems, web, and mobile technologies. Strange Loop is in St. Louis, MO, Oct 14-15th, 2010. Early bird registration for Strange Loop is just $150 (compare to JavaOne early bird price of $1595).

Keynote speakers for Strange Loop will include Guy Steele (Oracle), Douglas Crockford (Yahoo!), Hilary Mason (bit.ly), and Billy Newport (IBM). You can find a list of other already confirmed Strange Loop speakers.

Register or submit a talk today!

For "Alex Miller" at the very beginning, you actually listed a retweet I did as my talk. To be clear:

• Alex Miller, Jonas Boner -> "Scala and Clojure Java VM Languages", which is a comparison of how to accomplish important big-boned Java-like things (abstraction, concurrency, polymorphism, etc etc in Scala and Clojure).

The retweeted one was:

• Jesse Wilson, Kevin Bourrillion -> talk on microbenchmarking and their new tool Caliper ( http://bit.ly/bZVFHv )

Re mix-ins, it appears the door is open yet again to adding extension methods to Java. Extension methods are imho kind of ugly but do give you some of the functionality of mixins (the ability to effectively add methods after definition).

Re post-hoc interfaces, interface injection is another hot topic in the JVM world and would allow you to do this, as far as I understand it. That is of course at the JVM level and not at the Java level, but maybe some clever bytecode tool will open this up in some way.

I did a reasonably large poll about JDK version usage (and why people haven't switched) in summer of 2008. I thought the results were pretty interesting. In particular, I was surprised at how many reasons there were for people NOT switching, often well beyond the developer's control. At that point there was still heavy 1.4 usage. Would be interesting to re-do the poll now as some of the complaints around Apple or Websphere support for older versions have changed since then.

Result data

Result comment answers

Analysis

JavaOne has always been *the* conf for the top minds and the new wave in the Java world. A number of excellent conferences have taken up the torch over the last few years but they can't really hope to match the breadth and depth of JavaOne.

I hate to see JavaOne go as I greatly enjoyed it but maybe it would actually be a benefit to get those speakers out to other conferences in other places instead.

Speaking of which, my own little conference Strange Loop features a number of noted Java dudes like Alex Buckley (Java modularity), Bob Lee (JSR 330, Android), and Jesse Wilson (Guice) as well as talks about a bunch of other interesting languages (Ruby, Groovy, Clojure, Scala), and the latest in the NoSQL database world (MongoDB, Apache Cassandra). The conference is on Oct. 22 and 23 in St. Louis and there are just a handful of seats still open if you're interested in attending. Registration is just $130.

That's an interesting conjecture but seems woefully lacking in any kind of evidence. Honestly, I think it's too early to really make this comparison fairly in either case. Hotspot is really quite an amazing piece of engineering in many ways and is a hotbed of activity right now. And Parrot is also a re-think of how to approach a dynamic VM that is also a hotbed of interesting activity but I'm not sure I'd bet my production system on it just yet.

For me, I think there's great stuff going on in a bunch of VMs right now - JVM, CLR, Parrot, BEAM, whatever. It's a great time to be a language geek. A few years from now I think we'll be better able to make these comparisons.

@Zviki: You can run it on Macs with the SoyLatte OpenJDK 6 port. If I recall, you do need to start up the vm with the jmx stuff enabled (like you used to do on 1.5):

-Dcom.sun.management.jmxremote

I've also heard that the next preview now available on the Apple Developer's connection does now have visualvm included but I haven't tried that myself.

Excellent comments Rick. Seems like we are entering an interesting period for Java. The JCP will now be dominated by two superpowers, each with very strong business motivations to control and influence the future of Java. Obviously Oracle has the upper hand by controlling the JCP and the Java spec.

I would love to see the "special" status of one company removed and the JCP become a truly open organization. And while we're at it, we should resolve the field of use restrictions so ASF can finally be satisfied. Thus allowing a Java 7 JSR to be created. And I want a pony.

You're speaking my language man. This is exactly the point and focus of my talk Design Patterns Reconsidered which you can find here:

Design Patterns Reconsidered

I think if the GoF had called the book "Design Problem Patterns" that might have changed the focus a bit on identifying common problems and then discussing the many possible solutions/variations of those problems. In some cases, the problem is addressed directly in a language feature. But the problem (say the "expression problem" defined by Wadler addressed by the visitor pattern) continues to exist and need a solution, whether it's in the language or not.

@Peter yes, *if* you wrote your code with volatile (which you didn't) and *if* you are using jdk 1.5+ (which many aren't) then it will work. But I think it's simpler to just say, DO NOT USE DOUBLE-CHECKED LOCKING and leave it at that. In all cases, it is less code, simpler code, equally as thread-safe, and possibly better performance to use the initialize-on-demand-holder idiom (see many references above) if you need to lazily instantiate a singleton.

Josh Bloch recommends using an enum now to hold a singleton but I don't like this in all cases. My main beef is that some singletons are written with mutable state and I think it's morally wrong :) to mutate state in an enum instance. So, if you are registering and de-registering stuff in your singleton instance, then I object to holding it in an enum. But then, I reject the use of the singleton pattern at all. :)

@tranquiliser: no no no no and no. This is double-checked locking and it is NOT thread-safe. Without a memory barrier formed by synchronization on the read of instance, the instructions can be reordered and cause all sorts of thread problems. The badness that can occur will become more and more likely as we add cores. Do not do this. For more detail, read Bill Pugh's paper on why double-checked locking is broken.

I wrote some more comprehensive posts on singleton (why it sucks) and double-checked locking (why it's broken and better ways to initialize singleton) that may be of interest.

As mgaravaglia noted, your third example is not thread-safe and should not be used. The Initialize-On-Demand-Holder idiom is a better (and thread-safe) way to lazily initialize a singleton.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Yep, that fixed it. Although you presized the map to 1, which probably isn't big enough. :) The default for LinkedHashMap is 16.

Also, I should mention that Terracotta provides an easy way to distribute many of these open-source caches across multiple JVMs.

Before Java 5, the memory model defined in the Java Language Spec in ways that were both complicated and under-constrained. In particular, volatiles had somewhat different semantics on different platforms.

Java 5 addressed that with JSR 133. You can find copious information at Bill Pugh's site:

http://www.cs.umd.edu/~pugh/java/memoryModel/

Before Java 5, the memory model defined in the Java Language Spec in ways that were both complicated and under-constrained. In particular, volatiles had somewhat different semantics on different platforms.

Java 5 addressed that with JSR 133. You can find copious information at Bill Pugh's site:

http://www.cs.umd.edu/~pugh/java/memoryModel/

Before Java 5, the memory model defined in the Java Language Spec in ways that were both complicated and under-constrained. In particular, volatiles had somewhat different semantics on different platforms.

Java 5 addressed that with JSR 133. You can find copious information at Bill Pugh's site:

http://www.cs.umd.edu/~pugh/java/memoryModel/

I think those are generally known as Multi-Methods and are available in a few languages. Can't say I've seen anyone even considering adding them to Java 7. Maybe you can be the first. :)

Hopefully I'll have some time soon to continue playing with this!

I think you're both right that the power/complexity tradeoff is the most important thing to decide on. But I think syntax is important (but less so) because syntax affects so many things about how we perceive the feature and the language.

Stefan, I think you make an important point that less characters != better. Given two options of equal clarity and power, I'd take the one with less characters, but that kind of choice rarely occurs. More likely, clarity (and possibly power) are bound up in what those characters are. :)

Artur,

It sounds like you might benefit from some static or dynamic analysis tools for checking your concurrency issues. FindBugs is a great first pass to find inconsistent locking and other similar problems. Then I would use a profiling thread analyzer like JProbe, OptimizeIt, or YourKit. These tools do a pretty good job at finding data races, deadlocks, and monitor contention issues. If you haven't tried them yet, I think they'd be worth the effort.

It sounds to me like unit tests would not provide a lot of additional value so I wouldn't choose to invest my time there either. Seems like review and analysis tools are a better value.

The point of this post is really about how ReentrantLock gives you options that don't exist with synchronized blocks and methods. It's not an argument for or against the use of locks for protecting access to shared data.

In general, having one entity tell others what to do sounds to me like a prescription for low concurrency because all of the entities then have to coordinate at the central point. But it's hard to even talk about this without talking about real examples.

I don't know about you, but I lock my house, my car, etc every day. :) Lock-based access to shared state is *one* style of concurrent programming and happens to be the most prevalent in Java (for better or worse and mean argue for worse). Message-passing/actor-based or lock-free styles also exist and they all have their pros and cons.

I've written about ConcurrentSkipListMap in the past, which is an incredibly cool high-concurrency sorted map in Java 6 written with lock-free code. Lock-free data structures and algorithms rock. They're also incredibly tricky to get right (if you actually read the code for something like ConcurrentSkipListMap/Set or LinkedBlockingQueue). ReentrantLock itself is implemented with lock-free code actually.

Yep, this is an excellent point. tryLock() and any retry strategy can avoid deadlock but does not alleviate the potential for livelock where all threads are constantly retrying and never succeeding. In that case, you don't deadlock, but make no further progress.

I believe TCP uses an exponential backoff for stuff like this (although I haven't studied this in 10 years). A fascinating topic in itself, but outside the scope of this article... :)

Yep, this is an excellent point. tryLock() and any retry strategy can avoid deadlock but does not alleviate the potential for livelock where all threads are constantly retrying and never succeeding. In that case, you don't deadlock, but make no further progress.

I believe TCP uses an exponential backoff for stuff like this (although I haven't studied this in 10 years). A fascinating topic in itself, but outside the scope of this article... :)

Yep, this is an excellent point. tryLock() and any retry strategy can avoid deadlock but does not alleviate the potential for livelock where all threads are constantly retrying and never succeeding. In that case, you don't deadlock, but make no further progress.

I believe TCP uses an exponential backoff for stuff like this (although I haven't studied this in 10 years). A fascinating topic in itself, but outside the scope of this article... :)

Hey, I somehow published this with comments off - sorry about that!

A colleague of mine just coincidentally published a blog today about using distributed CyclicBarrier with Terracotta, which is an interesting companion to the article above.

Hey, I somehow published this with comments off - sorry about that!

A colleague of mine just coincidentally published a blog today about using distributed CyclicBarrier with Terracotta, which is an interesting companion to the article above.

@ng100699 (presumably Neal Gafter) - thanks for the update. I'll assume by the lack of any other corrections, that the rest is all correct. :)

@mm49838 - yep, I think ARM will get a little more fleshed out, and who knows, it may have legs regardless of which way closures go. There have been some ideas sketched out for reification and even for reconciling the collections library to work with both but to my eye it's not pretty. I'm guessing it's too much, especially on top of closures and everything else.

@aalmiray - yep, I've been doing some Groovy recently and I'm finding it very useful in thinking about what Java would be like with some of these features.