剑指Offer_2_实现Singleton模式

不好的解法：

• 方法一：仅支持单线程的单例模式，只有if判断。

public class NotSafeSingleton
{
    private static NotSafeSingleton instance = null;

    private NotSafeSingleton(){}

    public static NotSafeSingleton getInstance()
    {
        if (instance == null)
        {
            try
            {
                Thread.sleep(10);
            } catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            instance = new NotSafeSingleton();

        }
        return instance;
    }
}

• 方法二：支持多线程，但是效率很低的同步方法块。

可行的解法：

• 方法三：外层if(减少同步代码块被访问的次数) + 同步代码块(防止多线程访问) + 内层if(保证单例)

public class Singleton
{
    private static Singleton instance = null;
    private static final Object LOCKOBJ = new Object();

    private Singleton(){}

    public static Singleton getInstance()
    {
        if (instance == null)
        {
            synchronized (LOCKOBJ)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

推荐的解法:

• 方法四：饿汉式：线程安全，但是实例创建过早,当调用其中的某个静态方法时，实例就会被创建，但可能我们并不想创建这个实例

public class HungrySingleton
{
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton()
    {
    }

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

• 方法五：静态内部类：内部内部类会在被调用的时候 初始化外部类的静态实例，有效防止了过早创建实例的问题，且线程安全

public class InnerSingleton
{
    private InnerSingleton(){}

    public static InnerSingleton getInstance()
    {
        return SingletonHolder.instance;
    }

    private static class SingletonHolder
    {
        private static final InnerSingleton instance = new InnerSingleton();

    }
}

• 方法六：枚举方法（jdk1.5以后，推荐方法）