[concurrency-interest] syntax sugar for lazy instantiation

Ashley Williams ashpublic at mac.com
Tue Jun 23 13:05:24 EDT 2009


It seems to me that the only reason to use an intrinsic lock on a lazy  
getter (stick a synchronized keyword
on the method signature) is convenience of syntax. Please correct me  
if I am wrong.

So is one idea to simplify lazy instantiation, feedback welcome if  
anybody can improve on it. It's based
on the observation that double checked locking is mostly boilerplate  
except for the line that creates
the instance and so I've factored it out into a callable interface.

Admittedly the anonymous class makes for a more verbose constructor,  
but at least the dcl logic is
now encapsulated. And if java had support for closures then the  
readability problem would go away.

So first the class:

@ThreadSafe
public final class LazyField<T> {
	private volatile T obj;
	private final Callable<T> callable;

	public LazyField(Callable<T> callable) {
		this.callable = callable;
	}

	public T get() {
		if (obj == null) {
			synchronized (this) {
				if (obj == null) {
					obj = callable.call();
				}
			}
		}
		return obj;
	}
}

and here is an example usage:

@ThreadSafe
public final class MyClass {
	private final LazyField<String> message;

	public MyClass() {
		this.message = new LazyField<String>(new Callable<String>() {
			public String call() throws Exception {
				return "hello world";
			}
		});
	}

	public String getMessage() {
		return message.get();
	}
}

- Ashley Williams
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20090623/5b7fb3f3/attachment.html>


More information about the Concurrency-interest mailing list