单例模式

单例模式

单例模式是Java种最简单的设计模式之一。这种类型的设计模式属于创建者模式，它提供了一种创建对象的最佳方式。
这种设计方式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可用直接访问，不需要实例化对象。

注意：

• 1.单例类只能有一个实例。
• 2.单例类必须自己创建自己的唯一实例。
• 3.单例类必须给所有其他对象提供这一实例。

优点

• 1.在内存里只有一个实例，减少的内存的开销，尤其是那种频繁创建和销毁对象的场景。
• 2.避免对资源的多重占用(比如写文件操作)

缺点

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景

• 1.要求生产唯一序列号。
• 2.Web中的计数器，不用每次刷新都在数据库操作一次，用单例先缓存起来。
• 3.创建的一个对象需要消耗的资源过多，比如I/O与数据库的连接等等。

懒汉式，线程不安全

最常见也是最容易手写的单例模式——懒汉式(线程不安全)，但是此种写法使用的是懒加载模式，当多个线程并行调用getInstance()的时候，就会创建多个实例。也就是是说，此种创建方法不适用于多线程。

	public class Singleton {

	    //创建SingleObject的一个对象
	    private static Singleton instance ;
	
	    //让构造函数为private，这样该类就不会被实例化
	    private Singleton() {
	    }
	
	    //获取唯一可用的对象
	    public static Singleton getInstance() {
	        if(instance == null){
	        	instance = new Singleton();
	        }
	        return instance;
	    }
	}

懒汉式，线程安全

为了解决上面的问题，最简单的方法是在getInstance()方法上加synchronized

	public class Singleton {

	    //创建SingleObject的一个对象
	    private static Singleton instance ;
	
	    //让构造函数为private，这样该类就不会被实例化
	    private Singleton() {
	    }
	
	    //获取唯一可用的对象
	    public static synchronized Singleton getInstance() {
	        if(instance == null){
	        	instance = new Singleton();
	        }
	        return instance;
	    }
	}

虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。因为在任何时候只能有一个线程调用 getInstance() 方法。但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。

饿汉式

它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

优点：没有加锁，执行效率提高

缺点：类加载时就初始化，浪费内存

public class Singleton01 {

    //类加载时就初始化
    private static Singleton01 instance = new Singleton01();

    private Singleton01() {
    }

    public static Singleton01 getInstance() {
        if (instance == null) {
            instance = new Singleton01();
        }
        return instance;
    }

    public void showMessage() {
        System.out.println("饿汉式...线程安全!");
    }
}

双重检验锁

双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。

public class Singleton02 {

    private static Singleton02 instance;

    private Singleton02(){
    }

    public static Singleton02 getInstance() {
        if (instance == null) {                         //Single Checked
            synchronized (Singleton02.class) {
                if (instance == null) {                 //Double Checked
                    instance = new Singleton02();
                }
            }
        }
        return instance ;
    }

    public void showMessage() {
        System.out.println("双重校验锁...线程安全!");
    }
}

这段代码看起来很完美，很可惜，它是有问题。主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情：

1. 给instance分配内存
2. 调用 Singleton 的构造函数来初始化成员变量
3. 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在JVM的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的执行顺序是不能保证的，最终执行的顺序可能是1-2-3，也可能是1-3-2.如果是后者，则在3执行完毕、2未执行前，被线程2抢占了，这是instance已经是非null了(但没有初始化)，所以线程2会直接返回instance，然后使用吗，这时就会报错，因为instance还没有初始化完成。

我们只需要将instance变量声明为volatile就可以了。

public class Singleton02 {

    private volatile static Singleton02 instance;

    private Singleton02(){
    }

    public static Singleton02 getInstance() {
        if (instance == null) {                         //Single Checked
            synchronized (Singleton02.class) {
                if (instance == null) {                 //Double Checked
                    instance = new Singleton02();
                }
            }
        }
        return instance ;
    }

    public void showMessage() {
        System.out.println("双重校验锁...线程安全!");
    }
}

有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。

使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。

比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。

静态内部类

这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：
第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果）。

而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。

想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

public class Singleton03 {
    //静态内部类
    private static class SingletonHolder {
        private static final Singleton03 INSTANCE = new Singleton03();
    }

    private Singleton03() {
    }

    public static final Singleton03 getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public void showMessage() {
        System.out.println("静态内部类...线程安全!");
    }
}

实例使用

public class SingletonPatternDemo {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.showMessage();

        System.out.println("================");

        Singleton01 singleton01 = Singleton01.getInstance();
        singleton01.showMessage();

        System.out.println("================");

        Singleton02 singleton02 = Singleton02.getInstance();
        singleton02.showMessage();

        System.out.println("================");

        Singleton03 singleton03 = Singleton03.getInstance();
        singleton03.showMessage();

    }
}