[concurrency-interest] syntax sugar for lazy instantiation

Ashley Williams ashpublic at mac.com
Tue Jun 23 14:31:16 EDT 2009


Yes that makes a lot of sense - at the moment I'm also looking at  
groovy so I guess I'm seeing closures where
I don't always need them.


On 23 Jun 2009, at 18:49, Joe Bowbeer wrote:

> Instead of a separate Callable, you might consider providing an  
> abstract "construct" method for subclasses to override.  Then the  
> usage of LazyField would be similar to that of ThreadLocal.
>
> The user will need to create a class one way or another (Callable or  
> LazyField subclass), but the latter is often more compact:
>
>    message = new LazyField<String>() {
>         String construct() {
>             return "hello world";
>         }
>     }
>
> Joe
>
> On Tue, Jun 23, 2009 at 10:05 AM, Ashley Williams wrote:
> 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
>
>
> _______________________________________________
> Concurrency-interest mailing list
> Concurrency-interest at cs.oswego.edu
> http://cs.oswego.edu/mailman/listinfo/concurrency-interest

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


More information about the Concurrency-interest mailing list