优雅的单例

单例Singleton设计模式可能是被讨论和使用最广泛的一种设计模式了,首先我们从最开始的教学版本开始

public class Singleton {
    private static Singleton singleton = null;
    private Singleton() {  }
    public static Singleton getInstance() {
        if (singleton== null) {
            singleton= new Singleton();
        }
        return singleton;
    }
}

很多老师上课或者很多java教材中都会这样写
首先将此类的构造方法私有化,让其不能在其他地方调用new Singleton()在内存中分配一段空间存储这个对象
为了让外部变量能够访问这个独特的对象就要设计一个公共静态方法让其返回这个类的实例,而这个实例必须还要有一个引用去指向他,所以还必须要有一个私有静态变量保存这个引用.
当第一个外部变量准备访问这个单例的时候,由于singleton没有实例化,所以就会进入if循环,调用私有构造方法生成一个实例,以后需要这个实例的时候就不会进入if循环了
看似很不错的代码,却没有考虑到多线程情况下这个单例是否还是单例

public class SingletonTest {

    public static void main(String[] args) {

        Runnable r = () -> {
            Singleton s = Singleton.getInstance();
            System.out.println(s.toString());
        };

        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++)
            threads[i] = new Thread(r);
        for (Thread a : threads)
            a.start();
    }
}

比如我生成10个线程,每个线程都去访问getInstance()方法(我在私有的构造方法中多添加了一句输出语句)

    private Singleton() {
        System.out.println("生成一个Singleton");
    }

然后运行这个程序在控制台中就有可能输出这样的情况

上面的这个程序存在比较严重的问题，因为是全局性的实例，所以，在多线程情况下，所有的全局共享的东西都会变得非常的危险，这个也一样，在多线程情况下，如果多个线程同时调用getInstance()的话，那么，可能会有多个进程同时通过 (singleton== null)的条件检查，于是，多个实例就创建出来，并且很可能造成内存泄露问题。
下面我们将Singleton改进一下

public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
        System.out.println("生成一个Singleton");
    }

    public static Singleton getInstance() {
        if (singleton == null)
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        return singleton;
    }
}

其实也就是用synchronized 将singleton = new Singleton();方法包起来,其实如果再运行一次SingletonTest的main方法就会发现还是会生成很多对象,因为如果多个线程通过if(singleton == null)语句后即使让他们同步还是会生成很多对象,所以我们就应该用synchronized将if语句块包起来

public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
        System.out.println("生成一个Singleton");
    }

    public static Singleton getInstance() {
        synchronized (Singleton.class) {
            if (singleton == null)
                singleton = new Singleton();
        }
        return singleton;
    }
}

如果这样做了的话就会发现多次运行main方法后就只会生成一个对象,这样做是不是就万事大吉了呢?其实这样做后还是有一点现问题,那就是当很多线程同时调用getInstance()方法的时候这些线程就会被同步,本来我们只是想让if方法同步就行了,现在却将整个方法都同步了.也就是说当第一个线程生成对象后,后面的线程就没有必要同步进入方法依次判断是否生成对象了.这样做的话效率就会非常的低下.那么下面我们再次改一下这个Singleton

public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
        System.out.println("生成一个Singleton");
    }

    public static Singleton getInstance() {
        if (singleton == null)
            synchronized (Singleton.class) {
                if (singleton == null)
                    singleton = new Singleton();
            }
        return singleton;
    }
}

在同步代码块之前就判断singleton是否生成对象,这样做叫做Double-Check
1. 第一个if是说，如果实例创建了，那就不需要同步了，直接返回就好了。
2. 不然，我们就开始同步线程。
3. 第二个条件是说，如果被同步的线程中，有一个线程创建了对象，那么别的线程就不用再创建了。
代码如果这样写的话看似就飞铲完美了,但是还是存在一个问题,主要在于singleton = new Singleton()这一句代码,他并不是一个原子操作,在jvm中这句话大概做了以下三件事情
1. 给 singleton 分配内存
2. 调用 Singleton 的构造函数来初始化成员变量，形成实例
3. 将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null 了）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
对此，我们只需要把singleton声明成 volatile 就可以了。

public class Singleton {
    private static volatile Singleton singleton = null;

    private Singleton() {
        System.out.println("生成一个Singleton");
    }

    public static Singleton getInstance() {
        if (singleton == null)
            synchronized (Singleton.class) {
                if (singleton == null)
                    singleton = new Singleton();
            }
        return singleton;
    }
}

使用 volatile 有两个功用：
1）这个变量不会在多个线程中存在复本，直接从内存读取。
2）这个关键字会禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。
但是，这个事情仅在Java 1.5版后有用，1.5版之前用这个变量也有问题，因为老版本的Java的内存模型是有缺陷的。
上面的玩法实在是太复杂了，一点也不优雅，下面是一种更为优雅的方式：
这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。

public class Singleton
{
    private volatile static Singleton singleton = new Singleton();
    private Singleton()  {    }
    public static Singleton getInstance()   {
        return singleton;
    }
}

但是，这种玩法的最大问题是——当这个类被加载的时候，new Singleton() 这句话就会被执行，就算是getInstance()没有被调用，类也被初始化了。
下面的这个1.6版是老版《Effective Java》中推荐的方式。

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

上面这种方式，仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它只有在getInstance()被调用时才会真正创建；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。

好了,上面说过了那是老版本的示例代码
那么新effective java的代码又是怎么样的呢?

public enum Singleton{
   INSTANCE;
}

居然用枚举！！看上去好牛逼，通过EasySingleton.INSTANCE来访问，这比调用getInstance()方法简单多了。
默认枚举实例的创建是线程安全的，所以不需要担心线程安全的问题。但是在枚举中的其他任何方法的线程安全由程序员自己负责。还有防止上面的通过反射机制调用私用构造器。