How to implement thread-safe lazy initialization?

What are some recommended approaches to achieving thread-safe lazy initialization? For instance,

// Not thread-safe
public Foo getInstance(){
    if(INSTANCE == null){
        INSTANCE = new Foo();
    }

    return INSTANCE;
}

If you're using Apache Commons Lang, then you can use one of the variations of ConcurrentInitializer like LazyInitializer.

Example:

ConcurrentInitializer<Foo> lazyInitializer = new LazyInitializer<Foo>() {

		@Override
		protected Foo initialize() throws ConcurrentException {
			return new Foo();
		}
	};

You can now safely get Foo (gets initialized only once):

Foo instance = lazyInitializer.get();

If you're using Google's Guava:

Supplier<Foo> fooSupplier = Suppliers.memoize(new Supplier<Foo>() {
    public Foo get() {
        return new Foo();
    }
});

Then call it by Foo f = fooSupplier.get();

From Suppliers.memoize javadoc: > Returns a supplier which caches the instance retrieved during the first call to get() and returns that value on subsequent calls to get(). The returned supplier is thread-safe. The delegate's get() method will be invoked at most once. If delegate is an instance created by an earlier call to memoize, it is returned directly.

For singletons there is an elegant solution by delegating the task to the JVM code for static initialization.

public class Something {
    private Something() {
    }

    private static class LazyHolder {
            public static final Something INSTANCE = new Something();
    }

    public static Something getInstance() {
            return LazyHolder.INSTANCE;
    }
}

see

http://en.wikipedia.org/wiki/Initialization_on_demand_holder_idiom

and this blog post of Crazy Bob Lee

http://blog.crazybob.org/2007/01/lazy-loading-singletons.html

This can be done in lock-free manner by using AtomicReference as instance holder:

// in class declaration
private AtomicReference<Foo> instance = new AtomicReference<>(null);  

public Foo getInstance() {
   Foo foo = instance.get();
   if (foo == null) {
       foo = new Foo();                       // create and initialize actual instance
       if (instance.compareAndSet(null, foo)) // CAS succeeded
           return foo;
       else                                   // CAS failed: other thread set an object 
           return instance.get();             
   } else {
       return foo;
   }
}

Main disadvantage here is that multiple threads can concurrently instantiate two or more Foo objects, and only one will be lucky to be set up, so if instantiation requires I/O or another shared resource, this method may not be suitable.

At the other side, this approach is lock-free and wait-free: if one thread which first entered this method is stuck, it won't affect execution of others.

The easiest way is to use a static inner holder class :

public class Singleton {

    private Singleton() {
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }

    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
}

class Foo {
  private volatile Helper helper = null;
  public Helper getHelper() {
    if (helper == null) {
      synchronized(this) {
        if (helper == null) {
          helper = new Helper();
        }
      }
    }
  return helper;
}

This is called double checking! Check this http://jeremymanson.blogspot.com/2008/05/double-checked-locking.html

If you use lombok in your project, you can use a feature described here.

You just create a field, annotate it with @Getter(lazy=true) and add initialization, like this: @Getter(lazy=true) private final Foo instance = new Foo();

You'll have to reference field only with getter (see notes in lombok docs), but in most cases that's what we need.

Thinking about lazy initialization, I would expect getting a "almost real" object that just decorates the still not initialized object.

When the first method is being invoked, the instance within the decorated interface will be initialized.

* Because of the Proxy usage, the initiated object must implement the passed interface.

* The difference from other solutions is the encapsulation of the initiation from the usage. You start working directly with DataSource as if it was initialized. It will be initialized on the first method's invocation.

Usage:

DataSource ds = LazyLoadDecorator.create(dsSupplier, DataSource.class)

Behind the scenes:

public class LazyLoadDecorator<T> implements InvocationHandler {

	private final Object syncLock = new Object();
	protected volatile T inner;
	private Supplier<T> supplier;

	private LazyLoadDecorator(Supplier<T> supplier) {
		this.supplier = supplier;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if (inner == null) {
			synchronized (syncLock) {
				if (inner == null) {
					inner = load();
				}
			}
		}
		return method.invoke(inner, args);
	}

	protected T load() {
		return supplier.get();
	}

	@SuppressWarnings("unchecked")
	public static <T> T create(Supplier<T> factory, Class<T> clazz) {
		return (T) Proxy.newProxyInstance(LazyLoadDecorator.class.getClassLoader(),
				new Class[] {clazz},
				new LazyLoadDecorator<>(factory));
	}
}

Here is one more approach which is based on one-time-executor semantic.

The full solution with bunch of usage examples can be found on github (https://github.com/ManasjyotiSharma/java_lazy_init). Here is the crux of it:

“One Time Executor” semantic as the name suggests has below properties:

1. A wrapper object which wraps a function F. In current context F is a function/lambda expression which holds the initialization/de-initialization code.

2. The wrapper provides an execute method which behaves as:

   • Calls the function F the first time execute is called and caches the output of F.
   • If 2 or more threads call execute concurrently, only one “gets in” and the others block till the one which “got in” is done.
   • For all other/future invocations of execute, it does not call F rather simply returns the previously cached output.

3. The cached output can be safely accessed from outside of the initialization context.

This can be used for initialization as well as non-idempotent de-initialization too.

import java.util.Objects;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;

/**
 * When execute is called, it is guaranteed that the input function will be applied exactly once. 
 * Further it's also guaranteed that execute will return only when the input function was applied
 * by the calling thread or some other thread OR if the calling thread is interrupted.
 */

public class OneTimeExecutor<T, R> {  
  private final Function<T, R> function;
  private final AtomicBoolean preGuard;
  private final CountDownLatch postGuard;
  private final AtomicReference<R> value;

  public OneTimeExecutor(Function<T, R> function) {
    Objects.requireNonNull(function, "function cannot be null");
    this.function = function;
    this.preGuard = new AtomicBoolean(false);
    this.postGuard = new CountDownLatch(1);
    this.value = new AtomicReference<R>();
  }
  
  public R execute(T input) throws InterruptedException {
    if (preGuard.compareAndSet(false, true)) {
      try {
        value.set(function.apply(input));
      } finally {
        postGuard.countDown();
      }
    } else if (postGuard.getCount() != 0) {
      postGuard.await();
    }
    return value();
  }
  
  public boolean executed() {
    return (preGuard.get() && postGuard.getCount() == 0);
  }
  
  public R value() {
    return value.get();
  }

}  

Here is a sample usage:

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;

/*
 * For the sake of this example, assume that creating a PrintWriter is a costly operation and we'd want to lazily initialize it.
 * Further assume that the cleanup/close implementation is non-idempotent. In other words, just like initialization, the 
 * de-initialization should also happen once and only once.
 */
public class NonSingletonSampleB {
  private final OneTimeExecutor<File, PrintWriter> initializer = new OneTimeExecutor<>(
    (File configFile) -> {
      try { 
        FileOutputStream fos = new FileOutputStream(configFile);
        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
        BufferedWriter bw = new BufferedWriter(osw);
        PrintWriter pw = new PrintWriter(bw);
        return pw;
      } catch (IOException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
      }
    }
  );  

  private final OneTimeExecutor<Void, Void> deinitializer = new OneTimeExecutor<>(
    (Void v) -> {
      if (initializer.executed() && null != initializer.value()) {
        initializer.value().close();
      }
      return null;
    }
  );  
  
  private final File file;
  
  public NonSingletonSampleB(File file) {
    this.file = file;
  }
  
  public void doSomething() throws Exception {
    // Create one-and-only-one instance of PrintWriter only when someone calls doSomething().  
    PrintWriter pw = initializer.execute(file);
    
    // Application logic goes here, say write something to the file using the PrintWriter.
  }

  public void close() throws Exception {
    // non-idempotent close, the de-initialization lambda is invoked only once. 
    deinitializer.execute(null);
  }

}

For few more examples (e.g. singleton initialization which requires some data available only at run-time thus unable to instantiate it in a static block) please refer to the github link mentioned above.

Put the code in a synchronized block with some suitable lock. There are some other highly specialist techniques, but I'd suggest avoiding those unless absolutely necessary.

Also you've used SHOUTY case, which tends to indicate a static but an instance method. If it is really static, I suggest you make sure it isn't in any way mutable. If it's just an expensive to create static immutable, then class loading is lazy anyway. You may want to move it to a different (possibly nested) class to delay creation to the absolute last possible moment.

Depending on what you try to achieve:

If you want all Threads to share the same instance, you can make the method synchronized. This will be sufficient

If you want to make a separate INSTANCE for each Thread, you should use java.lang.ThreadLocal

With Java 8 we can achieve lazy initialization with thread safety. If we have Holder class and it needs some heavy resources then we can lazy load the heavy resource like this.

public class Holder {
    private Supplier<Heavy> heavy = () -> createAndCacheHeavy();

    private synchronized Heavy createAndCacheHeavy() {

        class HeavyFactory implements Supplier<Heavy> {
            private final Heavy heavyInstance = new Heavy();

            @Override
            public Heavy get() {
                return heavyInstance;
            }
        }
        if (!HeavyFactory.class.isInstance(heavy)) {
            heavy = new HeavyFactory();
        }
        return heavy.get();
    }

    public Heavy getHeavy() {
        return heavy.get();
    }
}

public class Heavy {
    public Heavy() {
        System.out.println("creating heavy");
    }
}

Basing this answer on @Alexsalauyou's one I thought if it could be possible to implement a solution that does not call multiple instances.

In principle my solution may be a little bit slower (very very little), but it is definitely friendlier to the processor, and the garbage collector.

The idea is that you must first use a container which could hold an "int" value PLUS the generic you want to instance.

static class Container<T> {
   final int i; 
   final T val; 
   //constructor here
}

Let this container's fields be final for concurrency purposes.

The LazyInit<T> class, must have an AtomicReference of this container.

AtomicReference<Container<T>> ref;

LazyInit must define phase processes as private static int constants:

private static final int NULL_PHASE = -1, CREATING_PHASE = 0, CREATED = 1;

private final Container<T> NULL = new Container<>(NULL_PHASE, null),
CREATING = new Container<>(CREATING_PHASE, null);

The AtomicReference must be initialized as NULL:

private final AtomicReference<Container<T>> ref = new AtomicReference<>(NULL);

Finally the get() method would look like this:

@Override
public T get() {
    Container<T> prev;
    do {
        if (ref.compareAndSet(NULL, CREATING)) {
            T res = builder.get();
            ref.set(new Container<>(CREATED, res));
            return res;
        } else {
            prev = ref.get();
            if (prev.i == CREATED) return prev.value;
        }
    } while (prev.i < CREATED);
    return prev.value;
}

Try to defined the method which gets an instance as synchronized:

public synchronized Foo getInstance(){
   if(INSTANCE == null){
    INSTANCE = new Foo();
  }

  return INSTANCE;
 }

Or use a variable:

private static final String LOCK = "LOCK";
public synchronized Foo getInstance(){
  synchronized(LOCK){
     if(INSTANCE == null){
       INSTANCE = new Foo();
     }
  }
  return INSTANCE;
 }