java 单例模式

• 意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
• 主要解决：一个全局使用的类频繁地创建与销毁。
• 何时使用：当您想控制实例数目，节省系统资源的时候。
• 如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
• 关键代码：构造函数是私有的。

懒汉式，线程不安全

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;
    }
}

使用枚举除了线程安全和防止反射强行调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。