在上篇文章中，我们讲了单例模式中的饿汉式，今天接着来讲懒汉式。
public class LazySingleton {
private static LazySingleton instance = null;
// 让构造函数为private，这样该类就不会被实例化
private LazySingleton() {
}
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
public long getRamAddress() {
return this.hashCode();
}
}懒汉式的特点在于有需要时才实例化。
在多线程的环境下，getInstance方法会导致线程不安全。因为在getInstance时，可能A、B两个线程几乎同时进入，在A实例化未完成的情况下，B判断实例仍然为null，因此继续实例化，这样有实例化了两个不同的对象，明显违背了单例的初衷。这里可以稍微验证一下线程安全问题，为了方便验证，在getInstance让当前线程sleep：
public static LazySingleton getInstance() {
if (instance == null) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new LazySingleton();
}
return instance;
}测试代码：
/**
* 公共方法，在多线程环境下测试单例，避免重复编写测试代码
* @param threadCount 线程数
* @param func 函数，用于获取单例
* @param <T>
*/
public static <T> void singLetonMultiThread(int threadCount, Supplier<T> func) {
ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
IntStream.range(0, threadCount).forEach(i -> {
executorService.submit(() -> {
System.out.println(func.get());
});
});
// 等线程全部执行完后关闭线程池
executorService.shutdown();
try {
executorService.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void lazySingLetonTest() {
Supplier func = () -> LazySingleton.getInstance();
singLetonMultiThread(10, func);
}测试结果如下：
十个线程里出现了8个不同的对象！
我们需要改进一下getInstance方法，考虑到效率问题，我们不想直接在getInstance方法上加锁，因为这种方式下每次调用getInstance()时都需要进行线程锁定判断，在多线程高并发访问环境中，将会导致系统性能大大降低。于是，我们得在判断实例是否为空时加锁，并且进行双重检查：
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class) {
// 这里需要再判断一次，因为可能有其它线程已经创建实例
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}这样看起来似乎是解决了问题了。
但这还有瑕疵。对于：
instance = new LazySingleton();这个创建对象的语句其实是个非原子操作，在极端的多线程环境下，会存在安全问题。对象的创建过程，在执行的时候分解成以下三条指令：
memory=allocate(); //1.分配对象的内存空间
ctorInstance(memory); //2.执行构造方法来初始化对象
instance=memory; //3.设置instance指向刚分配的内存地址
正常执行顺序应该是1->2->3，但可能指令会被重排序为1->3->2，也就是说，2、3步有可能发生指令重排导致重排序，因为synchronized只能保证有序性，但无法禁止指令重排。假设有两个线程A、B，在双重检查锁内，从cpu时间片上的执行顺序如下：
A线程执行完3还没执行2，虽然分配了内存空间已，但是还没初始化对象，而此时B线程进来判断(instance == null)，由于instance已经指向了内存空间，所以instance != null，于是直接返回了对象，但此时对象还未初始化。这样一来，线程B将得到一个还没有被初始化的对象。
为了防止指令重排，需在声明instance对象时加上volatile关键词：
public class LazySingleton {
// volatile，确保本条指令不会因编译器的优化而省略，且要求每次直接读值
private static volatile LazySingleton instance = null;
// 让构造函数为private，这样该类就不会被实例化
private LazySingleton() {
//System.out.println("懒汉式单例初始化！");
}
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class) {
// 这里需要再判断一次，因为可能有其它线程已经创建实例
if (instance == null) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
instance = new LazySingleton();
}
}
}
return instance;
}
public long getRamAddress() {
return this.hashCode();
}
} volatile关键词具备以下功能:
1. 避免编译器将变量缓存在寄存器里
2. 避免编译器调整代码执行的顺序
使用volatile声明的变量可以强制屏蔽编译器和JIT的优化工作，能够防止双重检查锁的指令重排。
正如在上篇文章饿汉式单例中所说的那样，懒汉式同样有反射的问题。我们采用跟懒汉式一样的方法常识防止破坏单例：
public class LazySingleton {
private static volatile LazySingleton instance = null;
// 让构造函数为private，这样该类就不会被实例化
private LazySingleton() {
//System.out.println("懒汉式单例初始化！");
synchronized (LazySingleton.class) {
if(instance != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
}
public static LazySingleton getInstance() {
if (instance == null) {
synchronized (LazySingleton.class) {
// 这里需要再判断一次，因为可能有其它线程已经创建实例
if (instance == null) {
instance = new LazySingleton();
}
}
}
return instance;
}
public long getRamAddress() {
return this.hashCode();
}
}再测试一下看看：
public static void LazySingletonReflectionTest() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Class<LazySingleton> clazz = LazySingleton.class;
// 获取HungrySingLeton的默认构造函数
Constructor<LazySingleton> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
// 调用默认构造函数创建实例
LazySingleton h1 = constructor.newInstance();
LazySingleton h2 = constructor.newInstance();
System.out.println(h1.getRamAddress());
System.out.println(h2.getRamAddress());
}运行结果：
没用！因为在类加载的时候，懒汉式单例根本就没有对单例进行初始化，然后反射通过构造函数获取单例，获取的对象都是不同的，所以没法防止反射破坏。当然，如果是先通过getInstance获取单例，再反射，这种情况下就可以防止反射，如：
public static void reflectionTest2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
LazySingleton h0 = LazySingleton.getInstance();
Class<LazySingleton> clazz = (Class<LazySingleton>) h0.getClass();
// 获取HungrySingLeton的默认构造函数
Constructor<LazySingleton> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
// 调用默认构造函数创建实例
LazySingleton h1 = constructor.newInstance();
System.out.println(h0.getRamAddress());
System.out.println(h1.getRamAddress());
}懒汉式单例对这个问题没有好的解决办法。
单例模式存在线程安全、反射、序列化漏洞的问题，虽然可以想办法解决，但代码也比较臃肿了。换个角度，可以用枚举来实现，去规避这些问题。
public enum Singleton {
INSTANCE;
public void doSomething() {
System.out.println("这里实现自己的业务");
}
}先测试一下枚举单例的反射：
public static void enumSingletonRlectionTest() throws NoSuchMethodException,
IllegalAccessException, InvocationTargetException, InstantiationException {
Singleton instance1 = Singleton.INSTANCE;
Constructor<Singleton> declaredConstructor = Singleton.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
//java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init>()
Singleton instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}结果抛出异常 ，没有构造函数Singleton.<init>()：
这并非防止了反射。枚举Enum是个抽象类，它有个构造函数：
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}我们定义了枚举类单例，实际上就是继承了Enum，所以会有（String.class,int.class）的构造器，测试方法改造下：
public static void enumSingletonRlectionTest() throws NoSuchMethodException,
IllegalAccessException, InvocationTargetException, InstantiationException {
Singleton instance1 = Singleton.INSTANCE;
Constructor<Singleton> declaredConstructor = Singleton.class.
getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
//java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init>()
Singleton instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}结果如下：
Cannot reflectively create enum objects(无法以反射方式创建枚举对象)，可以防止反射，因为反射在通过构造函数的newInstance方法创建对象时，会检查该类是否ENUM修饰，如果是则抛出异常，反射失败。所以枚举类不能通过反射来创建对象
普通的Java类的反序列化过程中，会通过反射调用类的默认构造函数来初始化对象。所以，即使单例中构造函数是私有的，也会被反射给破坏掉。由于反序列化后的对象是重新new出来的，所以这就破坏了单例，必须新增readResolve方法才能防止破坏。
但是，枚举的反序列化并不是通过反射实现的。在序列化时，Java仅仅是将枚举对象的name属性输出到结果中，反序列化时则通过java.lang.Enum的valueOf(String name) 方法，根据名字查找内存中是否已经有该对象，若找到了就会直接使用它，如果不存在就会抛出异常。同时。编译器不允许任何对这种序列化机制的定制，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。这样一来，序列化的方式就无法创建新的对象了，也就不会发生由于反序列化导致的单例破坏问题。
实际测试一下：
public static void enumSingletonSerializable() {
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
File file = new File("d:\\Singleton.txt");
// -----------序列化-------------
// 创建输出流
oos = new ObjectOutputStream(new FileOutputStream(file));
//将单例对象写到文件中 序列化
oos.writeObject(Singleton.INSTANCE);
oos.flush();
// -----------反序列化-------------
// 从文件读取单例对象
ois = new ObjectInputStream(new FileInputStream(file));
// 反序列化得到对象singLeton
Singleton singLeton= (Singleton)ois.readObject();
System.out.println(singLeton == Singleton.INSTANCE); //false
file.deleteOnExit();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(oos != null) {
oos.close();
}
if(ois != null) {
ois.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试结果：
当我们使用enmu来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承；同时，编译器所创建的类中，属性和方法也都是都是static类型的，因为static类型的属性会在类被加载之后被初始化。当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的（因为虚拟机在加载枚举的类的时候，会使用ClassLoader的loadClass方法，而这个方法使用同步代码块保证了线程安全）。所以，创建一个enum类型是线程安全的。所以，创建一个enum类型是线程安全的。
基于前面的分析，单例类的线程安全问题，主要就是单例初始化过程中的线程安全问题。而由于枚举的以上特性，枚举实现的单例是天生线程安全的。所以用枚举实现的单例是最好的方式！
参考文章：