单例设计模式出现的问题

代码示例

class Demo implements Runnable{
    public void run() {
        Single.getInstance();
    }
}

饿汉式

饿汉式多线程并发没有问题

class Single {
    private static final Single SINGLE = new Single();
    private Single(){}


    public static  Single getInstance()
    {
        return SINGLE;
    }
}

懒汉式

传统懒汉式并发状态下出现问题

class Single {
    private static Single single = null;
    private Single(){}
    public static Single getInstance()
    {
        //所有的线程都可以并发进入此函数，进行此条件的判断
        if (single == null)
        {
            return new Single();
        }
        return single;
    }
}

加入同步后的懒汉式

class Single {
    private static Single single = null;
    private Single(){}
    /**
     * 并发访问会有安全隐患，所以加入同步机制，但是降低的效率
     * @return
     */
    public static /*synchronized*/ Single getInstance()
    {
        //所有的线程都可以并发进入此函数，进行此条件的判断
        synchronized (Single.class)
        {
            if (single == null)
            {
                return new Single();
            }
        }
        return single;
    }
}

改进效率后的懒汉式

class Single {
    private static Single single = null;
    private Single(){}
    /**
     * 并发访问会有安全隐患，所以加入同步机制，但是降低的效率
     * 解决方法如下：
     * 可以通过双重判断的方式解决效率问题，减少判断锁的次数
     * @return
     */
    public static /*synchronized*/ Single getInstance()
    {
        //所有的线程都可以并发进入此函数，进行此条件的判断
        if (single == null)
        {
            synchronized (Single.class)
            {
                if (single == null)
                {
                    return new Single();
                }
            }
        }
        return single;
    }
}