单例模式总结

单例模式是我们面试中经常会遇到的一道题，看似简单，实则有很多玄机，今天来好好总结一下：

1. 饿汉模式

饿汉模式的单例模式是一种较为简单的写法，代码如下：

public class Singleton{    private static Singleton instance = new Singleton();    private Singleton(){    }    public static Singleton getInstance(){        return instance;    }}

优点

虽然写法简单，但不要小瞧它，它是线程安全的绝对单例，当面试时被要求写一个线程安全的单例模式时完全可以用这个写法，还可以引申出一些其他的问题。

缺点

这种写法的缺点也比较明显，就是在有其他静态方法时，实例会在还没有使用它们的时候就加载好了，当对象很大时会造成对内存资源的浪费。
还有就是它不能防止反序列化和反射时产生新的实例。

PS:
-反序列化: 序列化是指把JAVA对象转换为字节流的过程，与之相对反序列化就是将字节流重构为JAVA对象的过程。
-反射：指程序在运行过程中可以获取到类的属性和方法，实现动态创建对象。

2. 懒汉模式

懒汉模式的代码如下：

public class Singleton{    private static Singleton instance = null;    private Singleton(){    }    public static Singleton getInstance(){        if(null == instance){            instance = new Singleton();        }        return instance;    }}

优点

解决了饿汉模式下出现的问题，实例在未被使用时不会被创建，采用了延迟加载的办法

缺点

非线程安全，当两个线程发现instance都为null时，就会都去执行初始化操作。
不能防止反序列化和反射产生新的实例。

3.方法锁

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

优点

线程安全的绝对单例，面试时可写。

缺点

由于方法体中可能还存在其他功能，方法加锁会导致并发性能下降。
无法防止反序列化和反射产生新的实例。

4.双重检查锁

public class Singleton{    private static Singleton instance = null;    private Singleton(){    }    public static Singleton getInstance(){        if(null == instance){// one            synchronized(Singleton.class){                if(null == instance){// two                    instance = new Singleton();// three                }            }        }        return instance;    }}

优点

与方法锁相比，并发性能更高。

缺点

并非绝对线程安全。
无法防止反序列化和反射产生新的实例。

线程不安全的原因：
java指令乱序执行，代码中three部分执行时分为三部分：
1 在内存中分配一块内存
2 调用构造方法
3 将内存地址指向instance（此时instance不为null）

正常是123的执行顺序，但是由于java指令乱序执行的特点，有可能出现132的情况，例如两个线程A和B，线程A在获得时间片按照132的指令顺序执行，当执行到2时，线程B获得到时间片，此时instance已经不为null，直接返回了instance，但此时构造方法还没有执行，返回的instance是未被初始化的对象，会产生错误。

5.双重检查锁与volatile联用

public class Singleton{    private static volatile Singleton instance = null;    private Singleton(){    }    public static Singleton getInstance(){        if(null == instance){            synchronized(Singleton.class){                if(null == instance){                    instance = new Singleton();                }            }        }        return instance;    }}

优点

线程安全并且绝对单例。
线程安全的原因：
volatile不仅可以每次都从主存中读取变量，而且还屏蔽了指令重排，所以通过volatile修饰后一定是指令一定按照顺序执行的。

缺点

无法防止反序列化和反射产生新的实例。

6.静态内部类

public class Singleton{    private static class InnerHolder{        static final Singleton instance = new Singleton();    }    private Singleton(){    }    public static Singleton getInstance(){        return InnerHolder.instance;    }}

优点

只有在使用的时候才会加载实例，这是这种写法与饿汉模式的区别，而且这种写法也是线程安全并且绝对单例。
线程安全的原因：
static修饰的类只会被初始化一次。

缺点

无法防止反序列化和反射产生新的实例。

7.枚举类

public class SingletonFactory{    private enum EnumSingleton{        factory;        private Singleton instance;        private EnumSingleton(){            instance = new Singleton();        }        public static Singleton getInstance(){            return instance;        }    }    public static Singleton getInstance(){        return EnumSingleton.factory.getInstance();    }}class Singleton{    public Singleton(){    }}

优点

枚举类的构造方法是在类加载时被实例化，因此也是线程安全并且绝对单例，同时防止反射和反序列化产生的新的实例。

缺点

与饿汉模式类似，会影响并发性能。

---

写在最后

今天老大让和一个有9年工作经验的来面试的人聊聊技术，我就让他写一个线程安全的单例模式，结果他写了一个方法锁的写法，里面用了两次synchronized，我问他问什么要用两次，结果他说这是在网上看到的云云，具体原因也没说出来，感觉就是死记硬背下来的，关键是还没写对。
我觉得通过这事也给自己敲响了警钟，如果做事情不求甚解，这样子混个5年甚至10年又有什么用呢，和两三年工作经验的人水平差不了多少。一定要趁着年轻多积累多研究，加油！