Initialization on demand holder idiom

Question

From Wikipedia I learnt that this code is thread safe:
public class Something {
     private Something() {
     private static class LazyHolder {
          private static final Something INSTANCE = new Something();
     public static Something getInstance() {
          return LazyHolder.INSTANCE;
}But can the same trick be used with a non-static method?
public class Something {
    private static class LazyHolder {
        private static final Something INSTANCE = new Something();
    public Something getInstance() {
        return LazyHolder.INSTANCE;
}How about using static blocks?
public class Something {
    private static class LazyHolder {
        private static final Something INSTANCE;
        static {
            INSTANCE = new Something();
    public Something getInstance() {
        return LazyHolder.INSTANCE;
}I'm asking this because I really want to initialize a time consuming object only once, but I can't expose static methods.
Another thing, how about a thread safe lazy accessor (at instance level)? Can it be done without applying "synchronized" to the whole method?
    public synchronized Something getInstance() {
        if (something != null) {
            something = new Something();
        return something;
    }

Answer 1

Peter,
Thank you.
Life cycle goes like this:
->Client receives a FacadeService (via a remote invocation, so I really don't have much control on how many instances are available, but I know there can be more than one FacadeService instance in memory).
-> Client calls a method in his Facade Service instance
-> The method perform heavy calculations, network access and database operations. When it is done, the result object gets cached locally and then returned to the client
-> Client calls other method
-> The same thing happen and other objects are cached locally.
-> Client calls one of the above Methods
-> method quickly return the cached result
Client will use the Facade in a Concurrent environment, and it is our responsibility to make it all thread safe.
So, what I want to do is mimic the behavior of Something like this:
public class ServiceFacadeImpl {
    // Results are Immutable objects
    private Result1 result1;
    private Result2 result2;
    public Result1 getResult1() {
        if (result1 == null) {
            // heavy operation to create result1
        return result1;
    public Result2 getResult2() {
        if (result2 == null) {
            // heavy operation to create result2
        return result2;
}In a thread safe fashion.
Using "synchronized" methods would be a way... But I'm sure it can be done in a less restrictive way (having every method, even the ones that would simple return a cache result, waiting for other method to finish it's long operations in order to get the object lock just don't do it).
public synchronized Result1 getResult1() {
        if (result1 == null) {
            // heavy operation to create result1
        return result1;
    }Double-checked locking isn't thread safe
Demand holder idiom is.
So, back to question 1, is this thread safe?
public class ServiceFacadeImpl {
    private Result1 result1;
    private Result2 result2;
    private static class LazyHolder1 {
        private static final Result1 INSTANCE = new Result1();
    private static class LazyHolder2 {
        private static final Result2 INSTANCE = new Result2();
    public Result1 getResult1() {
        return LazyHolder1.INSTANCE;
    public Result2 getResult2() {
        return LazyHolder2.INSTANCE;
    public static void main(String[] args) {
        ServiceFacadeImpl sfi = new ServiceFacadeImpl();
        sfi.getResult1();
        sfi.getResult2();
}And question 2: Is there a way to implement a less restrictive lazy load approach without appealing to static inner classes? I would love to cache Result1 and Result2 as ServiceFacadeImpl instance variables instead of static inner class - static variables lol).
Inner Enums are cool, but as you told me, they are implicit static, plus the
public enum SomethingFactory {
  INSTANCE;
  public Something createInstance() {
      return new SomethingElse();
} approach don't work since newSomethingElse() (that represents heavy computation) will be called every time.
I could use a enum Constructor Approach like this:
    public enum Factory1 {
        INSTANCE;
        Result1 result = new Result1();
   public enum Factory2 {
        INSTANCE;
        Result2 result = new Result2();
   public Result1 getResult1() {
        return Factory1.INSTANCE.result;
    public Result2 getResult2() {
        return Factory2.INSTANCE.result;
    }I can't have a enum Factory holding all results because the constructors for all of its values are called at once... So I would have to mantain a lot of enums like enum Factory1, enum Factory2, etc, just like the static inner classes case. Lazy Loading a instance variable in a non restrictive / thread safe way in java is proving to be quite challenging.