＜Java＞单例模式(Singleton)

什么是单例模式

单例模式，保证一个类在整个系统中仅有一个实例，并提供一个访问它的全局访问点

例如：代表JVM运行环境的Runtime类

要点

（1）某个类只能有一个实例，外面不能随意地创建

方法：构造器私有化

（2）这个类必须自行创建这个实例

使用一个该类的静态变量来保存这个唯一实例

（3）这个类必须自行向整个系统提供这个实例

对外提供获取该实例对象的方式
	1）直接暴露（设置静态变量访问权限为public）
	2）用静态变量的get方法获取

实现方式

饿汉式：直接创建对象，不存在线程安全问题
懒汉式：延迟创建对象

区别：
饿汉式：不管用户是否会使用到这个对象，都会创建这个对象
懒汉式：不到万不得已就不创建这个对象

（1）饿汉式

/*
饿汉式：直接创建实例对象，不管是否需要创建这个对象

（1）构造器私有化
（2）自行创建，并且用静态变量保存
（3）向外提供实例
（4）强调这是一个单例，因此可以用final限定
 */
public class Singleton1 {

    //(2)(3)(4),public,static,final
    public static final Singleton1 INSTANCE=new Singleton1();

    //（1）构造器私有化
    private Singleton1()
    {

    }
}

为什么说“不管用户是否会使用到这个对象，都会创建这个对象”呢？因为假如类Singleton1有一个静态方法test()

public static void test(){…}

那么实际上调用test()方法只需要类名调用即可，不需要使用到实例对象，但是由于 INSTANCE是静态常量，因此在加载并初始化类Singleton1的时候，这个静态对象就已经被创建出来了，所以说“不管用户是否会使用到这个对象，都会创建这个对象”

（2）懒汉式

线程不安全

/**
 * 1、构造器私有化
 * 2、用一个静态变量保存这个唯一的实例
 * 3、提供一个静态方法，获取这个实例对象
 */
public class Singleton2 
{

    static Singleton2 instance;
    private Singleton2() {}

    public static Singleton2 getInstance() 
    {
            if (instance == null) 
            {
                instance = new Singleton2();
            }
            return instance;

    }
}

多线程同时访问Singleton2类时，调用getInstance()方法，有可能会创建多个实例

因此给操作共享数据的代码进行加锁处理，确保当一个线程在操作共享数据时，其它线程只能阻塞，直到该对象被释放才能操作共享数据

线程安全（多线程）

/**
 * 1、构造器私有化
 * 2、用一个静态变量保存这个唯一的实例
 * 3、提供一个静态方法，获取这个实例对象
 */

public class Singleton3
{
    static Singleton3 instance;
    private Singleton3() {}

    public static Singleton3 getInstance()
    {
		//在同一时刻加了锁的程序部分只有一个线程可以进入
        synchronized (Singleton3.class)
        {
            if (instance == null)
            {
                instance = new Singleton3();
            }
            return instance;
        }
    }
}

但是这里每次调用getInstance()方法都需要synchronized，导致性能降低，可以使用双重锁定的方法进行改良

双重锁定

/**
 * 1、构造器私有化
 * 2、用一个静态变量保存这个唯一的实例
 * 3、提供一个静态方法，获取这个实例对象
 */
public class Singleton3
{
    static Singleton3 instance;
    private Singleton3() {}

    public static Singleton3 getInstance()
    {
    	//先判断实例是否存在，不存在再加锁处理
        if (instance == null)
        {
            synchronized (Singleton3.class)
            {
                if (instance == null)
                {
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }
}

设置两重instance是否存在判断的原因

（1）对于instance存在的情况，就直接返回
（2）当instance为null，并且同时有两个线程调用getInstance()方法时，它们将都可以通过第一重instance == null的判断。然后由于synchronized，这两个线程只能有一个线程进入，另一个处于阻塞。而此时如果没有第二重的instance == null判断，则第一个线程创建了实例，而第二个线程还是可以继续创建新的实例，就达不到单例的目的

使用双重锁定可以不用让线程每次执行getInstance()方法都加锁，而是只在实例instance未被创建时再加锁处理。既保证了多线程安全，效率相比上一个方法也有所提高