Sometimes we need to defer the object creation until it is needed.
The reasons may be various like creation is time/resource consuming (database connection etc.) and we want to speed up application startup.
This is a use case for the lazy initialization pattern.
We have a a following service interface and implementation that returns current time:
Let's imagine that the initialization is very costly.
Simple lazy initialization could look as follows:
We're creating DefaultService only once when we're invoking getTime method.
This solution is fine in single threaded environment (we will cover multi threaded environment later).
The problem arises when the service does not have few methods but a lot of them (it may happen when you're using some legacy or not well designed library).
Such implementation would look awful in this situation - you would have to implement every method and try to initialize the object in all of them.
In that case we can create a proxy object that would lazy initialization for each method invocation.
To create such proxy we need to implement java.lang.reflect.InvocationHandler interface.
There are some pitfalls the we need to overcome (more info here), that's why it's easier to use Guava's AbstractInvocationHandler:
The only thing left is thread safety. We can implement it on our own, but the safest way is to use ConcurrentInitializer from commons-lang:
I chose LazyInitializer that uses double-checked idiom but there are other implementation that might be more useful depending on the context.
Let's run all the implementations and see how they work (notice when the info about initialization is printed on the console) :
The whole project can be found on github.