懒汉模式
1.将构造方法私有化，不允许外部直接创建对象
2.声明类的唯一的实例，使用private static修饰
3.提供一个用于实例的方法，使用public static修饰
public class Singleton {
private singleton() {
}
private static Singleton instance ;
public Singleton getInstance() {
if (instance = null) {
instance = new Singleton();
}
return instance;
}
}
饿汉模式
1.将构造方法私有化，不允许外部直接创建对象
2.创建类的唯一实例
3.提供一个用于获取实例的方法
public class Singleton {
private Singleton() {
}
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
很多人包括我写单例的时候，第一想到的就是懒汉式
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
代码很简单，而且是懒加载，只有调用getInstance方法是才会初始化。但是这样是线程不安全的，即当多个线程并行调用getInstance的时候，就会创建多个实例，不能正常工作。
所以这里就有了加锁方式，将整个getInstance方法设为同步，添加synchronized关键字。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
这样简单粗暴的方式，虽然做到了线程安全，但导致了同一时间内只能有一个线程能够调用getInstance方法。
其实我们仅仅需要对初始化的代码进行同步，这就有了双重检验锁方式。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) { //第一次检查
synchronized (Singleton.class) {
if(instance == null) { //第二次检查
instance = new Singleton();
}
}
}
return instance;
}
}
这里第二次检查，是因为如果有多个线程同时执行完了第一次检查，这时如果同步块内不进行第二次检查的话，会生成多个实例了。
但是看了相关资料后，发现这样还是有点问题。引用资料中的介绍：
由于instance = new Singleton()，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
1.给 instance 分配内存
2.调用 Singleton 的构造函数来初始化成员变量
3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
我们只需要将 instance 变量声明成 volatile 就可以了。