剑指Offer_2_实现Singleton模式

2017-03-14

不好的解法：

方法一：仅支持单线程的单例模式，只有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以后，推荐方法）