java singleton模式四种线程安全的实现

1.描述:

    Singleton(单例)是设计模式的一种,为了保证一个类仅有一个实例，并提供一个访问它的全局访问点。

2.主要特色:     

    1)单例类确保本身只有一个实例(构造函数私有:不被外部实例化,也不被继承)。

    2)单例类必须本身建立本身的实例。

    3)单例类必须为其余对象提供惟一的实例。

3.单例模式的应用：

    资源管理器,回收站,打印机资源,线程池,缓存,配置信息类,管理类,控制类,门面类,代理类一般被设计为单例类

    若是程序有多个类加载器又同时使用单例模式就有可能多个单例并存就要找相应解决方法了

4.实现方法:

若是应用程序老是建立并使用单例实例或在建立和运行时开销不大。

1).Eager initialization 饿汉式单例类(依赖jvm在加载类时建立惟一单例实例)

public class EagerSingleton {  
        // jvm保证在任何线程访问uniqueInstance静态变量以前必定先建立了此实例  
        private static EagerSingleton uniqueInstance = new EagerSingleton();  
  
        // 私有的默认构造子，保证外界没法直接实例化  
        private EagerSingleton() {  
        }  
  
        // 提供全局访问点获取惟一的实例  
        public static EagerSingleton getInstance() {  
                return uniqueInstance;  
        }  
}

若是开销比较大，但愿用到时才建立就要考虑延迟实例化,或者Singleton的初始化须要某些外部资源(好比网络或存储设备),就要用后面的方法了.

 

2)Lazy initialization 懒汉式单例类

public class LazySingleton {  
        private static LazySingleton uniqueInstance;  
  
        private LazySingleton() {  
        }  
  
        public static synchronized LazySingleton getInstance() {  
                if (uniqueInstance == null)  
                        uniqueInstance = new LazySingleton();  
                return uniqueInstance;  
        }  
}

同步一个方法可能形成程序执行效率降低100倍，彻底没有必要每次调用getInstance都加锁，事实上咱们只想保证一次初始化成功，其他的快速返回而已,若是在getInstance频繁使用的地方就要考虑从新优化了.

 

3)"双检锁"(Double-Checked Lock)尽可能将"加锁"推迟,只在须要时"加锁"(仅适用于Java 5.0 以上版本,volatile保证原子操做) 
happens-before:"什么什么必定在什么什么以前运行",也就是保证顺序性.
如今的CPU有乱序执行的能力(也就是指令会乱序或并行运行,能够不按咱们写代码的顺序执行内存的存取过程),而且多个CPU之间的缓存也不保证明时同步,只有上面的happens-before所规定的状况下才保证顺序性.

JVM可以根据CPU的特性(CPU的多级缓存系统、多核处理器等)适当的从新排序机器指令,使机器指令更符合CPU的执行特色，最大限度的发挥机器的性能.

若是没有volatile修饰符则可能出现一个线程t1的B操做和另外一线程t2的C操做之间对instance的读写没有happens-before，可能会形成的现象是t1的B操做尚未彻底构形成功，但t2的C已经看到instance为非空，这样t2就直接返回了未彻底构造的instance的引用，t2想对instance进行操做就会出问题.

    volatile 的功能:
1. 避免编译器将变量缓存在寄存器里  
2. 避免编译器调整代码执行的顺序

优化器在用到这个变量时必须每次都当心地从新读取这个变量的值，而不是使用保存在寄存器里的备份。

public class DoubleCheckedLockingSingleton {  
        // java中使用双重检查锁定机制,因为Java编译器和JIT的优化的缘由系统没法保证咱们指望的执行次序。  
        // 在java5.0修改了内存模型,使用volatile声明的变量能够强制屏蔽编译器和JIT的优化工做  
        private volatile static DoubleCheckedLockingSingleton uniqueInstance;  
  
        private DoubleCheckedLockingSingleton() {  
        }  
  
        public static DoubleCheckedLockingSingleton getInstance() {  
                if (uniqueInstance == null) {  
                        synchronized (DoubleCheckedLockingSingleton.class) {  
                                if (uniqueInstance == null) {  
                                        uniqueInstance = new DoubleCheckedLockingSingleton();  
                                }  
                        }  
                }  
                return uniqueInstance;  
        }  
}

4)Lazy initialization holder class 知足全部 Double-Checked Locking 知足的条件，而且没有显示的同步操做

public class LazyInitHolderSingleton {  
        private LazyInitHolderSingleton() {  
        }  
  
        private static class SingletonHolder {  
                private static final LazyInitHolderSingleton INSTANCE = new LazyInitHolderSingleton();  
        }  
  
        public static LazyInitHolderSingleton getInstance() {  
                return SingletonHolder.INSTANCE;  
        }  
}

根据jvm规范，当某对象第一次调用LazyInitHolderSingleton.getInstance()时，LazyInitHolderSingleton类被首次主动使用，jvm对其进行初始化（此时并不会调用LazyInitHolderSingleton()构造方法），而后LazyInitHolderSingleton调用getInstance()方法，该方法中，又首次主动使用了SingletonHolder类，因此要对SingletonHolder类进行初始化，初始化中，INSTANCE常量被赋值时才调用了 LazyInitHolderSingleton的构造方法LazyInitHolderSingleton()，完成了实例化并返回该实例。

当再有对象（也许是在别的线程中）再次调用LazyInitHolderSingleton.getInstance()时，由于已经初始化过了，不会再进行初始化步骤，因此直接返回INSTANCE常量即同一个LazyInitHolderSingleton实例。