- 意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
- 主要解决：一个全局使用的类频繁地创建与销毁。
- 何时使用：当您想控制实例数目，节省系统资源的时候。
- 如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
- 关键代码：构造函数是私有的。
懒汉式，线程不安全
package singleton;
/**
* author: TAOPENG
* time ： 2019/3/21
**/
public class SingletonOne {
/**
* 懒汉模式，需要的时候再创建，属于懒加载
* 但是会造成线程安全问题，多线程会创建多个instance
*/
private static SingletonOne singletonOne;
private SingletonOne() {
}
public static SingletonOne getInstance() {
if (singletonOne == null) {
return singletonOne = new SingletonOne();
}
return singletonOne;
}
}
懒汉式，线程安全
- 虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。因为在任何时候只能有一个线程调用 getInstance() 方法。但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。这就引出了双重检验锁。
package singleton;
/**
* author: TAOPENG
* time ： 2019/3/21
**/
public class SingletonOne {
/**
* 懒汉模式，需要的时候再创建，属于懒加载
* 但是会造成线程安全问题，多线程会创建多个instance
* 使用synchronized修饰方法，解决多线程问题
*/
private static SingletonOne singletonOne;
private SingletonOne() {
}
public static synchronized SingletonOne getInstance() {
if (singletonOne == null) {
return singletonOne = new SingletonOne();
}
return singletonOne;
}
}
双重检验锁
双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。
public static SingletonOne getInstance() {
if (singletonOne == null) {
synchronized (SingletonOne.class) {
if (singletonOne == null) {
return singletonOne = new SingletonOne();
}
return singletonOne;
}
}
return singletonOne;
}
这段代码看起来很完美，很可惜，它是有问题。主要在于singletonOne = new SingletonOne()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
- 1、给 singletonOne 分配内存
- 2、调用 SingletonOne的构造函数来初始化成员变量
- 3、将singletonOne 对象指向分配的内存空间（执行完这步 singletonOne 就为非 null 了）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 singletonOne 已经是非 null 了（但却没有初始化），所以线程二会直接返回 singletonOne ，然后使用，然后顺理成章地报错。
我们只需要将 singletonOne 变量声明成volatile 就可以了。
package singleton;
/**
* author: TAOPENG
* time ： 2019/3/21
**/
public class SingletonOne {
/**
* 懒汉模式，需要的时候再创建，属于懒加载
* 但是会造成线程安全问题，多线程会创建多个instance
* 使用synchronized修饰方法，解决多线程问题
* 但是 new SingletonOne() 不是原子操作，所以如果不加volatile会出问题
*/
private static volatile SingletonOne singletonOne;
private SingletonOne() {
}
public static SingletonOne getInstance() {
if (singletonOne == null) {
synchronized (SingletonOne.class) {
if (singletonOne == null) {
return singletonOne = new SingletonOne();
}
return singletonOne;
}
}
return singletonOne;
}
}
饿汉式 static final field
这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的
package singleton;
/**
* author: TAOPENG
* time ： 2019/3/21
**/
public class SingletonTwo {
/**
* 饿汉式创建，使用static final能保证类加载的时候就创建instance
* 能保证线程安全，不是懒加载的
* 缺点是不能通过配置文件动态生成，或者类加载之前必须使用参数定义他的配置参数
*/
private static final SingletonTwo SINGLETON_TWO = new SingletonTwo();
private SingletonTwo() {
}
public SingletonTwo getInstance() {
return SINGLETON_TWO
}
}
静态内部类
把Singleton实例放到一个静态内部类中，这样就避免了静态实例在Singleton类加载的时候就创建对象，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的
public class Singleton {
private static class Holder {
private static Singleton singleton = new Singleton();
}
private Singleton(){}
public static Singleton getSingleton(){
return Holder.singleton;
}
}
但是，上面提到的所有实现方式都有两个共同的缺点：
- 都需要额外的工作(Serializable、transient、readResolve())来实现序列化，否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。
- 可能会有人使用反射强行调用我们的私有构造器（如果要避免这种情况，可以修改构造器，让它在创建第二个实例的时候抛异常）。
使用枚举Enum
public enum Singleton {
INSTANCE;
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
使用枚举除了线程安全和防止反射强行调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。
