单例设计模式

简介

单例模式是设计模式中的创建型设计模式，用来保证一个类只能创建一个对象，通常包括饿汉式单例、懒汉式单例。

一、饿汉式单例

饿汉式单例是在类加载时就进行创建的，如：

public class Apple {

    //  由于是单例，因此构造函数需要私有化
    private Apple() {}
    //  饿汉式
    private final static Apple apple = new Apple();
    
    //  提供一种获取单例对象的方法
    public static Apple getInstance() {
        return apple;
    }
}

同时还可以利用枚举的性质，即一个枚举只有一个实例，来保证单例

public enum Orange {
    
    orange;
}

二、懒汉式单例

懒汉式单例是在需要单例对象时才进行加载，最简单的实现方式如下：

public class Apple {
    
	private Apple() {}
    private static Apple apple2;
	
    //	懒汉式
    public static Apple getInstance2() {
        if (apple2 == null) {
            apple2 = new Apple();
        }
        return apple2;
    }
}

但是这样会出现线程安全问题，多个线程同时获取单例对象判断apple2==null都成立，那么就会创建多个Apple对象，因此线程安全的版本如下：

public class Apple {

    //  线程安全的懒汉式
    //  加volatile保证数据的可见性以及禁止指令重排
    private volatile static Apple apple3;

    public static Apple getInstance3() {
        if (apple3 == null) {
            //  多个线程同时获取单例对象时会出现并发问题，比如多个线程同时判断apple2==null都成立
            synchronized (Apple.class) {
                if (apple3 == null) {
                    apple3 = new Apple();
                }
            }

        }
        return apple3;
    }
}

讲一下这里的几个关键的地方：

​ ① synchronized保证多个线程都进来时，只能有一个线程执行创建对象的逻辑

​ ② synchronized内部判断apple3==null，是为了防止第一个线程创建对象完毕之后，其他的线程再次创建对象

​ ③ 使用volatile关键字保证多线程下apple3数据的可见性，并且将该属性new对象的指令重排禁用，如果进行了指令重排，那么创建出来的将是不完整的对象
另外，还有一种更优雅的懒汉式单例

public class Apple {
	//	构造函数私有化
	private Apple() {
        if (LazySingletonCreateClass.apple4 != null) {
            throw new RuntimeException();
        }
    }
	//	获取单例
	public static Apple getInstance4() {
	   	return LazySingletonCreateClass.apple4;
	}
	
	//	静态内部类
	private static class LazySingletonCreateClass {
	    private volatile static Apple apple4 = new Apple();
	}
}

讲一下这里的几个关键点：
① 利用静态内部类使用时才会加载的特性实现懒加载
② 为了防止反射破坏单例，在构造函数中判断抛出异常，保证构造函数只能被执行一次