java设计模式——单例模式(一)
一. 定义与类型
定义：保证一个类仅有一个实例，并提供一个全局访问点
类型：创建型
二. 适用场景
想确保任何情况下都绝对只用一个实例
三. 优缺点
优点：
在内存里只有一个实例，减少了内存开销
可以避免对资源的多重占用
设置全局访问点，严格控制访问
缺点：
没有接口，扩展困难
四. 重点
私有构造器
线程安全
延迟加载
序列化和反序列化安全
反射
实用技能：反编译，内存原理，多线程Debug
五. 相关设计模式
单例模式和工厂模式
单例模式和享元模式
六. Coding
懒汉式：
/** * @program: designModel * @description: 懒汉单例,懒汉式注重的就是延迟加载，当在使用到这个实例的时候才会初始化 * @author: YuKai Fan * @create: 2018-12-04 14:04 **/ public class LazySingleton { private static LazySingleton lazySingleton = null; private LazySingleton() { } //如果只有这种方法，是线程不安全的。 //在多线程环境下，使用这个方法,会有概率的产生不止一个实例的情况，虽然最后返回的还是同样的独享 /*public static LazySingleton getInstance() { if (lazySingleton == null) { lazySingleton = new LazySingleton(); } return lazySingleton; }*/ //在方法上加锁，让这个方法每次只能有一个线程访问 /*public synchronized static LazySingleton getInstance() { if (lazySingleton == null) { lazySingleton = new LazySingleton(); } return lazySingleton; }*/ //在代码块上加锁，让这个方法每次只能有一个线程访问,这样只会产生一个实例 //这种方式，锁的是class类，存在加锁和解锁的开销，对性能有一定影响 public static LazySingleton getInstance() { synchronized(LazySingleton.class) { if (lazySingleton == null) { lazySingleton = new LazySingleton(); } } return lazySingleton; } }
如上方代码注释所说，懒汉式的注重点是延时加载，但是在性能和安全方面都所有影响，所以引出下面的双重检查模式
/** * @program: designModel * @description: 懒汉式双重检查。既符合延迟加载，也保证了安全性能 * @author: YuKai Fan * @create: 2018-12-04 14:35 **/ public class LazyDoubleCheckSingleton { //volatile关键字，使用解决了程序的重排序问题，即使在多线程的情况下，实例变量始终是最新的状态 //使用这种方法是不让下面的2，3发生重排序 private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null; private LazyDoubleCheckSingleton() { } public static LazyDoubleCheckSingleton getInstance() { if (lazyDoubleCheckSingleton == null) { synchronized (LazyDoubleCheckSingleton.class) { if (lazyDoubleCheckSingleton == null) { //1.分配内存给这个对象 //2.初始化对象 //3.设置LazyDoubleCheckSingleton 只向刚分配的内存地址 //其中2和3的顺序可能会被颠倒，倒置，判断为null的时候，已经初始化对象，此时并不为空 //intra-thread semantics 不会改变单线程程序的重排序 lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton(); } } } return lazyDoubleCheckSingleton; } }
双重检查，顾名思义是对实例的是否创建做了两层的判断，例如，当thread0,进入getInstance()，此时lazyDoubleCheckSingleton==null，两层的判断都会过，当刚刚走到new LazyDoubleCheckSingleton()时，thread1进入方法时，第一次判断其实lazyDoubleCheckSingleton还是为null，所以会通过，但是由于后面代码加锁，所以无法进入，当thread0执行玩方法时，释放锁，让thread1拿到，在进行判断，此时lazyDoubleCheckSingleton != null，就会直接退出，这样保证了在多线程环境下，始终只有一个实例。
刚开始的时候，我一直认为这样多此一举，为什么要在加锁的外面在判断一次。后来思考明白了，thread0，thread1的执行顺序，以及执行方法的时机在真正的环境下其实是不知道的，由操作系统来决定的。所以有可能是在thread0已经拿到实例的时候，此时thread1才进入方法，这时候这个判断就会不成立，也就不会在获取锁和释放锁，也就提高了程序的性能。
从上面的代码注释可知，这种方式存在重排序的问题，上面解决重排序的问题是使用volatile关键字，来防止重排序，还有一种方式是可以重排序，但是thread1，不会看到。
/** * @program: designModel * @description: 使用静态内部类来防止多线程环境下对DoubleCheck的懒汉式单例模式的判断实例问题，同时也允许重排序 * @author: YuKai Fan * @create: 2018-12-04 16:35 **/ public class StaticInnerClassSingleton { //使用静态内部类，是基于class对象的初始化锁的延迟加载方式，在线程0执行方法时会去实例，即使发生重排序，线程1也会被锁在初始化阶段 private static class InnerClass{ private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton(); } public static StaticInnerClassSingleton getInstance() { return InnerClass.staticInnerClassSingleton; } private StaticInnerClassSingleton() { } }
饿汉式：
这是一个很简单的单例模式的方式，它与懒汉式的最大的区别就是延时加载。饿汉式单例模式是在程序加载的时候，就创建实例，但是如果不用该实例，就会占用资源
/** * @program: designModel * @description: 饿汉式，与懒汉式最大的区别，就是延时加载，但是饿汉式如果不用该实例，会占用资源 * @author: YuKai Fan * @create: 2018-12-04 16:57 **/ public class HungrySingleton implements Serializable { private final static HungrySingleton hungrySingleton; static { hungrySingleton = new HungrySingleton(); } private HungrySingleton() { } public static HungrySingleton getInstance() { return hungrySingleton; } private Object readResolve() { return hungrySingleton; } }
单线程的执行顺序
多线程的执行顺序
