设计模式——单例模式

Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍四种：懒汉式单例、饿汉式单例、枚举实现单例和内部类单例。

单例模式有以下特点：

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

懒汉式单例

public class Singleton {
    //单例对象
    private static Singleton instance = null;
    //构造方法私有
    private Singleton(){}

    //静态工厂方法
    public static Singleton getInstance() {
        if(instance == null) {
        	 //并发会创建多个实例
            instance = new Singleton();
        }
        return instance;
    }
}

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例。

双重检查锁

public class Singleton1 {
    //单例对象
    private static volatile Singleton1 instance = null;
    //构造方法私有
    private Singleton1(){}

    //静态工厂方法
    public static Singleton1 getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton1();
                }
            }
        }
        return instance;
    }
}

这里使用了synchronized进行加锁，需要注意的是instance = new Singleton1()可能会发生指令重排，也就是还没有初始化完成就将对象指向了分配的地址，就会产生未初始化完成的对象。所以我们使用了volatile，这样会防止指令重排。

饿汉式单例

public class Singleton2 {
    //单例对象
    private static Singleton2 instance = new Singleton2();
    //构造方法私有
    private Singleton2(){}

    //饿汉模式
    public static Singleton2 getInstance() {
        return instance;
    }
}

饿汉模式是线程安全的，但是一开就创建对象，如果没有使用这个对象会造成浪费。

枚举单例模式

public class Singleton3 {
    //构造方法私有
    private Singleton3(){}

    public static Singleton3 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

    //枚举类
    private enum Singleton {
        INSTANCE;

        private Singleton3 singleton;
		 //jvm	
        Singleton() {
            singleton = new Singleton3();
        }

        public Singleton3 getInstance() {
            return singleton;
        }
    }
}

这里是由JVM保证的对象只会初始化一次，也只会在调用的时候初始化。

内部类单例

public class Singleton4 {
    //构造方法私有
    private Singleton4(){}

    private static class LazyHolder {
        private static final Singleton4 INSTANCE = new Singleton4();
    }

    public static Singleton4 getInstance() {
        return Singleton4.LazyHolder.INSTANCE;
    }
}

这种方式是最好的方法。jvm保证的线程安全，并且在调用的时候才会进行初始化。