Comments on: The Double Checked Locking confusion

By: michael

michael — Sat, 03 Jan 2009 17:43:29 +0000

Why the result variable is needed there?
Why is it not enough to add the volatile keyword?
when doing if (instance == null ) – read operation is performed.

Thanks

By: Alan van Dam

Alan van Dam — Wed, 17 Dec 2008 10:03:59 +0000

@Emiel, Your right the synchronise will not only create a monitor but it will also create memory bariers. But the problem here is the first check for null on the instance variable. This check is outside the synchronized block. So whithout the volatile there are no guarantees that it thread A sees the same as thread B that just created the instance. By using the volatile the second thread also need to update its memory. For a better explanation read http://www.javaworld.com/jw-02-2001/jw-0209-double.html?page=1

By: Emiel Paasschens

Emiel Paasschens — Tue, 16 Dec 2008 15:20:43 +0000

Why is volatile needed in the last example?
The synchronised keyword not only locks the specific code block to be accessed by one thread, but it will also synchronise local (thread) caches of all variables.
See also http://www.javaperformancetuning.com/news/qotm030.shtml

By: Alan van Dam

Alan van Dam — Mon, 15 Dec 2008 15:01:58 +0000

@Jean-Francois, Peter: You are both right. They were static before but then I thought maybe is better to avoid having this singleton thing and don’t be confusioning with more static keywords. But I forgot to rename my class Foo to Bar. Then again this looks a bit weird but I tried to get the focus on the real issue here.
I will fix this soon. Thanks for your comments.

By: Jean-Francois Poilpret

Jean-Francois Poilpret — Mon, 15 Dec 2008 10:44:43 +0000

Hi, I think you have forgotten “static” for examples 3, 4, 5 and 6 above. Both “instance” and “getInstance()” should be static else your code is impossible to execute (considering that Foo constructor is private which is a must for a singleton.

It is a pity to take the poor old singleton pattern (which is bad, I hope everybody is convinced of this) as an example for the double checked locking pattern. There are better examples (that make sense in the real world) than the singleton that anyway is a bad example by itself.

By: Peter Veentjer

Peter Veentjer — Mon, 15 Dec 2008 09:26:53 +0000

You can forget my first reply.. The submit functionality is quite lame, so sorry for spamming

By: Peter Veentjer

Peter Veentjer — Mon, 15 Dec 2008 09:25:28 +0000

You have forgotten a few statics:

public class Foo {
private final Foo instance = new Foo();
}

should be

public class Foo {
private static final Foo instance = new Foo();
}

The first example leads to a stackoverflow

But nice blogpost. Concurrency is a very hard topic to get right, and to be honest I’m really questioning the approach Java (and other normal oo languages) are taking. Perhaps Software Transactional Memory could mean to modern languages like garbage collection meant to java.

By: Ben Manes

Ben Manes — Mon, 15 Dec 2008 08:28:56 +0000

In your singleton-like example, the best is to use class-loader synchronization. I’m glad this is finally becoming popular, because so few people I’ve worked with would believe me until Josh started recommending it. Use either a static inner class to hold the parent’s instance or, if you prefer the newest style, use the enum trick.

For normal lazy initialization, the simplest approach (which is also quite efficent) is to use a FutureTask. I’m not sure why this isn’t popular, perhaps it doesn’t look magical enough to have the same coolness factor. Regardless, simply wrap the initialization logic in a Callable, create a FutureTask with it, and execute run() before the get() call. The first thread to call run() will change the task’s state and execute, while the rest will no-op. You can reuse this logic via a simple utility – mine is called a “LazyFuture”. The resulting code is fast, simple, and provides the desired behavior in a less error-prone manner. You also won’t run into bad practices, such as synchronizing on “this”, because the library does it cleanly for you. The only downside is that you don’t get to act like such a hot-shot since the code isn’t complex enough to brag about.