Java中的单例设计模式

Question

Double Lock check in Singleton is generally written as :

public static Singleton getInstance()
{ 
    if (instance == null)
    {
        synchronized(Singleton.class) {  //1
            if (instance == null)          //2
                  instance = new Singleton();  //3
        }
    }
    return instance; //4
} 

In the code above, suppose ten threads are calling this method, all of them crossed the first if condition, then one thread enters into the synchronized block and creates the instances. Remaining 9 thread would come one by one even if the instance is created they need to wait and come in sequence through the synchronized block. I want that as soon as any of the threads creates the Singleton instance all the other threads should not wait. Tell me if there is some solution for this?

Answer 1

I don't think there's a solution if you insist on using lazy instantiation. You could just create your singleton object when you declare the instance variable:

class Singleton {
    private static final instance = new Singleton();

    private Singleton() {} // prevent outside construction

    public static Singleton getInstance() {
        return instance; // no synchronization needed
    }
}

Thanks to the comment by eSniff (and the comment by yair to set me right about eSniff's comment), here's the method posted in Wikipedia for a thread-safe and lazy method:

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

    private Singleton() {} // prevent outside construction

    public static Singleton getInstance() {
        return Holder.instance; // no synchronization needed
    }
}

Answer 2

Did you test performance and reached the definite conclusion that you really need lazy initialization? If so, use the holder pattern :

public static class Singleton {
    private static class InstanceHolder {
        public static Singleton instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance() { 
        return InstanceHolder.instance;
    }
}

But , if you're not after decent performance test, than the most simple thing to do is to initialize the singleton in its instance declaration ( eager initialization ), like so:

public static class Singleton {
    public static Singleton instance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance() { 
        return instance;
    }
}

These two patterns, allow to rely on the class loading process to assure any thread that uses Singleton views a consistent instance. This way you achieve two benefits: code is more readable and runs faster.

BTW, the Double-Check-Idiom isn't thread safe unless your Singleton.instance is declared volatile .

Answer 3

If your 10 thread are using this Singleton object at same time then it will create problem in manipulation every thread modified this object in same time. to avoid this we used synchronized keyword so at a time only one thread can access object of Singleton class. if you want all thread can access this object at same time then remove synchronized keyword.