浅谈java设计模式---单例模式Singleton

单例模式介绍

单例模式是java设计模式之一，保证一个类只有一个实例，并提供一个全局访问入口

实现方式

1.懒汉式，线程不安全

1. 线程安全：否
2. 是否占用内存资源：否
3. 描述：是基本实现方式之一，懒加载，在getInstance()方法被调用时加载，但线程不安全，在多线程情况下存在多个实例问题（原因：如果同时有两个线程到达if(instance == null)时一个new完之后还会再new一个对象）

/**
 * 懒汉模式
 * 单例实例在第一次使用时进行创建
 */
public class Singleton {

    private static Singleton singleton = null;

    //私有构造函数，保证构造函数只在内部调用
    private Singleton(){

    }
    //静态工厂方法
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

此时我们创建两个线程多次运行后可能会出现如下情况

public class SingletonTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(()->test());
        Thread thread2 = new Thread(()->test());
        thread1.start();
        thread2.start();
    }

    public static void test(){
        System.out.println(Singleton.getInstance().hashCode());
    }

}

多次运行后可能出现的结果：

2.懒汉式，线程安全

1. 线程安全：是
2. 是否占用内存资源：否
3. 描述：在1的基础上加了synchronized，保证了线程安全，但是加锁后会影响效率，本来只是为了第一次new的同步，但现在只要进入getInstance()方法的线程都得同步，因为创建只有一次，后面都是读，读并不需要加锁

/**
 * 懒汉模式
 * 单例实例在第一次使用时进行创建
 */
public class Singleton {

    private static Singleton singleton = null;

    //私有构造函数，保证构造函数只在内部调用
    private Singleton(){

    }
    //静态工厂方法 加锁
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

3.双检锁/双重校验锁（DCL，即 double-checked locking）

1. 线程安全：是
2. 是否占用内存资源：否
3. 描述：在2的基础上将synchronized加在new前，进行写加锁读不加锁

/**
 1. 懒汉模式 -- 双重单例模式
 2. 单例实例在第一次使用时进行创建
 */
public class Singleton {

    private static Singleton singleton = null;

    //私有构造函数，保证构造函数只在内部调用
    private Singleton(){

    }

    /**
     * 1、memory = allocate() 分配对象的内存空间
     * 2、ctorInstance() 初始化对象
     * 3、singleton = memory 设置singleton指向刚分配的内存
     *
     * JVM和cpu优化，发生了指令重排序
     *
     * 1、memory = allocate() 分配对象的内存空间
     * 2、singleton = memory 设置singleton指向刚分配的内存
     * 3、ctorInstance() 初始化对象
     */
    //静态工厂方法
    public static Singleton getInstance(){
    	//双重检测机制，第一层判断，是确保多个线程同时进入下一层
        if(singleton == null){
        	//确保只有一个线程运行 锁内代码
            synchronized(Singleton.class){
            	 /**
                 * 第二层判断 第一个线程进来进行判断 如果不存在就在同步情况下创建		一个实例，
                 * 然后第二个线程进来在进行判断，重复判断是否存在，
                 * 故：第二个判断是防止生成多个实例，不可丢弃
                 */
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

但是以上方式依然是线程不安全，原因是存在重排序的问题，因为new 一个对象需要至少3步，并不是一个原子操作。 new 一个对象时 JVM大概做了以下3件事

1. 给singleton分配内存空间
2. 调用Singleton的构造函数来初始化成员变量，形成实例
3. 将singleton对象指向分配内存空间（完成此步后 才是非null）
   但是JVM在编译时存在指令重排序的优化，也就是说上面的步骤可能是1-2-3，也可能是1-3-2，如果是1-3-2的话，在3执行后 、2未执行前 被线程二抢占，这时singleton已经是非null（没有初始化），所以线程二返回singleton然后使用，导致报错。
   完善：这时使用volatile关键字，禁止指令重排。
   ps:volatitle阻止的不是singleton = new Singleton()这句话内部1-2-3的指令重排，而是保证了在一个写操作1-2-3完成之前，不会调用读操作if(singleton == null )
   改进后：

/**
 * 懒汉模式 -- 双重单例模式
 * 单例实例在第一次使用时进行创建
 */
public class Singleton {

    private volatile static Singleton singleton = null;

    //私有构造函数，保证构造函数只在内部调用
    private Singleton(){

    }

    /**
     * 1、memory = allocate() 分配对象的内存空间
     * 2、ctorInstance() 初始化对象
     * 3、singleton = memory 设置singleton指向刚分配的内存
     *
     * JVM和cpu优化，发生了指令重排序
     *
     * 1、memory = allocate() 分配对象的内存空间
     * 2、singleton = memory 设置singleton指向刚分配的内存
     * 3、ctorInstance() 初始化对象
     */
    //静态工厂方法
    public static Singleton getInstance(){
        //双重检测机制，第一层判断，是确保多个线程同时进入下一层
        if(singleton == null){
            //确保只有一个线程运行 锁内代码
            synchronized(Singleton.class){ //同步锁
                /**
                 * 第二层判断 第一个线程进来进行判断 如果不存在就在同步情况下创建一个实例，
                 * 然后第二个线程进来在进行判断，重复判断是否存在，
                 * 故：第二个判断是防止生成多个实例，不可丢弃
                 */


                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

4.饿汉模式

1. 线程安全：是
2. 是否占用内存资源：是
3. 描述：在类加载时就创建实例，避免了线程不安全问题，但缺点是:影响加载效率和占用内存资源浪费。

/**
 * 饿汉模式
 * 实例在类加载时创建
 */
public class Singleton {

    private volatile static Singleton singleton = new Singleton();

    //私有构造函数，保证构造函数只在内部调用
    private Singleton(){

    }

    public static Singleton getInstance() {
        return singleton;
    }
}

同样也可使用静态代码块来完成，但存在的问题和上面一样

/**
 * 饿汉模式
 * 实例在类加载时创建
 */
public class Singleton {

    private volatile static Singleton singleton = null;

    //私有构造函数，保证构造函数只在内部调用
    private Singleton(){

    }
    //静态代码块实例
    static {
        singleton = new Singleton();
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

5.懒汉模式–静态内部类

1. 线程安全：是
2. 是否占用内存资源：否
3. 描述：static修饰的内部类为静态内部类（内级内部类），静态内部类与外部类对象不存在依赖关系，同时内级内部类只有在第一次调用时才会加载，所以在内级内部类中创建实例可实现线程安全且不占用资源（只要多线程不在内部类中操作这个实例，只读的话那就是线程安全的）

/**
 * 懒汉模式 -- 静态内部类
 */
public class Singleton {

	//静态内部类
    private static class SingletonHolder{
        private static final Singleton SINGLETON = new Singleton();
    }
    private Singleton(){
        
    }
    public static final Singleton Singleton(){
        return SingletonHolder.SINGLETON;
    }
}

5.懒汉模式–枚举

1. 线程安全：是
2. 是否占用内存资源：否
3. 描述：默认枚举实例的创建是线程安全的，所以不需要担心线程安全的问题（反编译之后看到各个枚举项目通过static来定义和初始化，类加载时被初始化）

/**
 * 懒汉模式 -- 枚举
 */
public class Singleton {

    private Singleton(){

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

    private enum SingletonEnum{
        INSTANCE;
        private Singleton singleton;
        //JVM保证这个方法绝对只调用一次
        SingletonEnum(){
            singleton = new Singleton();
        }
        public Singleton getInstance(){
            return singleton;
        }
    }

}

此篇观安全发布对象—单例模式 有感