设计模式之单例模式

单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。这是个非常有意思的设计模式，使用和理解起来都比较简单，但是单例的写法有好多种，下面挑重点的介绍。

1. 饿汉式

public class Singleton1 {
    private static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1() {

    }

    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

优点：JVM保证线程安全，简单实用，推荐实用。

缺点：类加载时就会初始化。（话说你不用它怎么会初始化？所以发展出懒加载的形式）

2. 懒汉式

public class Singleton3 {
    private static Singleton3 INSTANCE;

    private Singleton3() {
    }

    public static Singleton3 getInstance() {

        if (INSTANCE == null) {
            INSTANCE = new Singleton3();
        }

        return INSTANCE;
    }
}

优点：懒加载，用的时候才会初始化。

缺点：线程不安全。（线程不安全就加锁呗！于是就是下面的版本）

public class Singleton4 {
    private static Singleton4 INSTANCE;

    private Singleton4() {
    }

    public static synchronized Singleton4 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton4();
        }
        return INSTANCE;
    }
}

优点：加锁了，线程安全。

缺点：加锁肯定是影响性能了，况且每次调用都需要获取锁，严重影响性能。（继续优化）

public class Singleton6 {
    private static volatile Singleton6 INSTANCE;
　　
    int value = 10;
    private Singleton6() {
    }

    public static Singleton6 getInstance() {
①        if (INSTANCE == null) {
            synchronized (Singleton5.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton6();
                }
            }
        }
        return INSTANCE;
    }
}

双重检查单例DCL(Double Checked Locking)，据说是完美的单例模式。注意必须要加volatile，原因如下。

Java对象的初始化其实分为3个步骤：

①分配内存创建对象，此时的对象只是赋予初始值，基本类型啥的就是0，false等等，引用类型就是null。如上面的int初始值就是0。

②初始化对象，给属性赋值（在定义class时指定的初始值），执行int = 10。

③将对象内存地址的句柄指向变量

JVM编译运行的时候为了指令的并行度，加快执行速度,在不改变单线程语义的情况下会执行指令重排序。上面的对象初始化三步有可能变为①③②，这样当多线程并发的时候执行到上述代码块的①时，INSTANCE对象可能不为空，但是对象中的属性还没有初始化，也就说得到的是一个半残的对象，拿着这个半残的对象去干活就有可能会出问题。

volatile有两个作用，保证内存的可见性，防止指令重排序。加了volatile就能防止对象的初始化顺序被改变。

下面再介绍两种更完美的单例模式（完美的单例真多。。。）

public class Singleton7 {

    private static class Child {
        private static final Singleton7 INSTANCE = new Singleton7();
    }

    private Singleton7() {
    }

    public static Singleton7 getInstance() {
        return Child.INSTANCE;
    }
}

基于类初始化的解决方案（外部类加载时不会加载内部类），完美写法的一种。线程安全、懒加载、无锁性能好。

public enum Singleton8 {
    INSTANCE;

    int a = 1;

    public void test(){
        int a = Singleton8.INSTANCE.a;
        Singleton8.INSTANCE.test();
        System.out.println("我是最完美的单例模式");
    }
}

比较诡异的写法，枚举（枚举是语法糖，本质是抽象类，跟普通的java类一样可以有属性方法）。这个是Effective Java的作者推荐的写法。优点太多（完美中的完美），能避免各种问题（线程安全、反序列化和反射都无法破坏单例）。

总结：虽然号称完美的单例模式很多，但是平时使用最基本的饿汉式就够用了，如有特殊的懒加载需求可以使用基于类初始化的解决方案。