单例模式

双检索单列：

double check lock
//综合了懒汉和恶汉的优点，解决了缺点
//及延迟了对象的实例化，有保证线程安全

关键点:

(1).私有构造函数;

(2).通过一个静态方法或者枚举返回单例类对象;

(3).确保单例类的对象有且只有一个,尤其是多线程环境下;

(4).确保単例类对象在反序列化时不会重新构建对象.

三.实现方式

1.饿汉式

/**
 * 恶汉
 * 线程安全  消耗资源
 */
public class SingleOne {
    private static final SingleOne singleOne = new SingleOne();

    private SingleOne() {
    }

    public static SingleOne getSingleOne() {
        return singleOne;
    }
}

2.懒汉式

/**
 * 懒汉式
 * 多线程不安全，消耗资源少
 */
public class SingleTwo {
    private static SingleTwo singleTwo;

    private SingleTwo() {
    }

    public static synchronized SingleTwo getInstance() {
        if (singleTwo == null) {
            singleTwo = new SingleTwo();
        }
        return singleTwo;
    }
}

3.Double Check Lock(DCL)

public class SingleThree {
    private static SingleThree singleThree = null;

    private SingleThree() {
    }

    public static SingleThree getInstance() {
        if (singleThree == null) {
            synchronized (SingleThree.class) {
                if (singleThree == null) {
                    singleThree = new SingleThree();
                }
            }
        }
        return singleThree;
    }
}

进行了两次非空判断:

(1).第一次避免不必要的同步;

(2).第二次是在非空的情况下创建实例.

上面写法是有缺陷的,应该将sInstance定义为private volatile static Singleton sInstance = null;具体分析如下:

假设A线程执行到是Instance= newSingleton();时,实际上它不是一个原子操作,它会被编译成多条汇编指令,大致做了3件事:

(1).给Singleton实例分配内存;

(2).调用Singleton的构造,初始化成员字段;

(3).将sInstance指向分配的内存空间(sInstance就不是null了).

但是由于Java编译器允许处理器乱序执行,以及JDK1.5之前JMM(Java Memory Model,java内存模型)中Cache,寄存器到主内存回写顺序的规定,上面(2)(3)执行顺序是无法保证的,有可能是1-3-2,然后被切换到B线程,sInstance已经非空了,B线程直接取走使用就会出错,这就是DCL失效问题,而且很难跟踪.(双重检查锁定失效)

所以JDK1.5及以后要将sInstance改为private volatile static Singleton sInstance = null,这样可以保证sInstance每次都从主内存中读取,当然volatile会影响一点性能.

DCL优点:资源利用率高;

缺点:第一次加载反应慢,在高并发环境下有一定缺陷,不过概率很小.