目录
单例模式
饿汉模式
懒汉模式
前言
多线程中有许多非常经典的设计模式（这就类似于围棋的棋谱），这是用来解决我们在开发中遇到很多 "经典场景"，简单来说，设计模式就是一份模板，可以套用。
单例模式
顾名思义，就是一个程序只能含有一个实例，有的场景中，希望一个类只能有一个对象，例如 JDBC 中的 DataSourse 实例就只需要一个。虽说程序员可以在编写代码时只给类创建一个对象，但是人毕竟没有机器靠谱，所以大佬们就设计了一套模板，按照模板来写代码，就不会出大的差错。
实现单例模式的方法有两种：饿汉模式 和 懒汉模式。
饿汉模式
就是在类加载时，就创建实例。
class SingleDemo{
//在类加载的时候创建
private static SingleDemo instance = new SingleDemo();
//设置为private是为了防止在其他类中 new 一个实例，这样就不是单例模式了
private SingleDemo(){ }
//既然不能在外面创建实例，我们就要提供一个方法来得到这个唯一的实例
public static SingleDemo getInstance() {
return instance;//读取操作
}
}懒汉模式
顾名思义，就是在用到实例的时候再创建实例，与饿汉模式相比，提高了代码的效率。
class SingleLazyDemo{
private static SingleLazyDemo instance = null;
//设置为private是为了防止在其他类中new一个实例
private SingleLazyDemo(){ }
public static SingleLazyDemo getSingleLazyDemo(){
//第一次需要实例时，创建实例
if(instance == null){
//修改操作
instance = new SingleLazyDemo();
}
return instance;//读取操作
}
}
了解了什么是饿汉模式和懒汉模式，我有一个问题：上述两种写法，那种是线程安全的？
我在前几篇博客中提到过，如果多个线程，同时修改同一个变量，此时就可能出现线程安全问题，所以显而易见，饿汉模式是线程安全的，它的方法中只涉及到读取操作，而懒汉模式是线程不安全的，它的方法中涉及到读取和修改操作。画个图理解一下：
接下来，我们就来解决懒汉模式的线程安全问题。导致该模式出现线程安全的原因其实在图中已经体现出来了，这个一个非原子操作，针对这一问题，我们的解决方法就是加锁。
class SingleLazyDemo{
private static SingleLazyDemo instance = null;
//设置为private是为了防止在其他类中new一个实例
private SingleLazyDemo(){ }
public static SingleLazyDemo getSingleLazyDemo(){
synchronized (SingleLazyDemo.class){//使修改操作变成原子操作
if(instance == null){//第一次需要实例时，创建实例
instance = new SingleLazyDemo();
}
}
return instance;
}
}此时，虽然懒汉模式的线程安全问题基本得到了解决，但是一旦这么写，后续每次调用 getInstance，都需要先加锁，而加锁的开销是很大的，只要涉及加锁，那么该代码就基本与"高性能"无缘了。实际上，我们的实例化对象的操作(即修改操作) 只是出现在第一次调用 getInstance 的时候。
一旦对象被new出来了，后续的线程调用 getInstance 就没有必要加锁了，因为这时候只用读取操作，线程是安全的，所以我们还需要再添加一个条件：
class SingleLazyDemo{
private static SingleLazyDemo instance = null;
//设置为private是为了防止在其他类中new一个实例
private SingleLazyDemo(){ }
public static SingleLazyDemo getSingleLazyDemo(){
if(instance == null){//判断是否线程安全，要不要加锁
synchronized (SingleLazyDemo.class){//使修改操作变成原子操作
if(instance == null){//判断是否实例化
instance = new SingleLazyDemo();
}
}
}
return instance;
}
}
注意：这两个 if 虽然都是判断 instance 是否为 null， 但是第一个 if 实际上是借此判断线程是否要加锁，如果为null，就说明需要执行修改操作，线程不安全，要加锁，如果不为null，说明线程只要执行读取操作，线程安全，不要加锁。而第二个 if 则是借此判断是否要实例化对象。
在经过上述修改后，此代码还有一个问题，这就涉及到了之前没细讲的指令重排序问题，该问题也是因为编译器优化导致的，编译器为了提高执行效率，可能会在逻辑顺序不变的情况下，调整原有代码的执行顺序。
比如：new 操作，可以分成三步：1. 申请内存空间 2. 在内存空间上构造对象 3. 把内存的地址赋值给 instance 引用。在单线程中，new 操作可以按照 1 2 3 执行，也可以按照 1 3 2 执行，但是在多线程中，1 3 2 这样执行就可能导致线程安全问题。
举个例子：当 t1 线程执行完 1 3 时，instance 就已经是非空了，这个时候 2 还没有执行，t2 线程就开始执行，因为这个时候 instance 非空，所以 t2 线程直接返回 instance，这个时候如果 t2 线程中的代码访问 Instance 中的属性和方法，那么就会出现BUG，因为 Instance 还没有构造对象。
这个问题就需要使用 volatile 关键字来修饰 Instance，这样就可以保证 Instance 在 new 的过程中不会出现指令重排序的现象，下面是最终的代码：
class SingleLazyDemo{
private static volatile SingleLazyDemo instance = null;
//设置为private是为了防止在其他类中new一个实例
private SingleLazyDemo(){ }
public static SingleLazyDemo getSingleLazyDemo(){
if(instance == null){//判断是否加锁
synchronized (SingleLazyDemo.class){//使修改操作变成原子操作
if(instance == null){//判断是否实例化
instance = new SingleLazyDemo();
}
}
}
return instance;
}
}
