Java 23种设计模式 之 单例模式

1、懒汉模式

        单例实例在第一次使用的时候进行创建。

1.1、线程不安全

1.1.1、代码1

public class SingletonExample1{
    
    private SingletonExample1(){}

    private static SingletonExample1 instance = null;

    public static SingletonExample1 getInstance(){
        // 多个线程同时调用，可能会创建多个对象
        if(instance == null){
            instance = new SingletonExample1();
        }
        return instance;
    }
}

1.1.2、代码2（双重锁同步锁单例模式）

• 当执行“instance = new SingletonExample();”这行代码时，CPU会执行如下指令：
  • 1.memory = allocate()：分配对象的内存空间
  • 2.ctorInstance()：初始化对象
  • 3.instance = memory：设置instance指向刚分配的内存
• 单纯执行以上三步没有问题，但是在多线程情况下，可能会发生指令重排序
  • 指令重排序对单线程没有影响，单线程下CPU可以按照顺序执行以上三个步骤，但是在多线程下如果发生了指令重排序，则会打乱上面的三个步骤
  • 如果发生了JVM和CPU优化，发生重排序时，可能会按照下面的顺序执行：
    • 1.memory = allocate()：分配对象的内存空间
    • 3.instance = memory：设置instance指向刚分配的内存
    • 2.ctorInstance()：初始化对象
• 假设目前有两个线程A和B同事之星getInstance()方法，A线程执行到“instance = new SingletonExample();”，B线程刚执行到第一个“if(instance == null)”处
• 如果按照1-3-2的顺序，假设线程A执行到“instance = memory”设置instance指向刚分配的内存，此时线程B判断instance已经有值，就会直接return instance；
• 而实际上，线程A还未执行“ctorInstance()”初始化对象，也就是说线程B拿到的instance对象还未初始化，这个未初始化的instance对象一旦被线程B使用，就会出现问题。

public class SingletonExample{

    private SingletonExample(){}

    private static SingletonExample instance = null;

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

1.1.3、代码3（volatile + 双重锁同步锁单例模式）

使用volatile关键字，保证可见性、禁止指令重排，但不保证原子性

可见性：多线程访问主内存的某一个资源时，如果某一个线程在自己的工作内存中修改了该资源，并写回主内存，那么JMM内存模型应该要通知其他线程来从新获取最新的资源（从通知其他线程重新获取最新资源到其他线程来获取资源时，资源会不会再次被改变？），来保证新资源的可见性。

禁止指令重排：instance = new SingletonExample()；对应的CPU指令顺序不再会因重排被打乱顺序，instance = memory指令一定最后执行。

不保证原子性，但在对第二个if(instance == null)外使用synchronized关键字，保证原子性。

public class SingletonExample{
    
    private SingletonExample(){}

    private volatile static SingletonExample instance = null;

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

}

1.2、线程安全

1.2.1、代码1

public class SingletonExample{
    
    private SingletonExample(){}

    private static SingletonExample instance = null;

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

1.2.2、代码2

2、饥汉模式

2.1、线程不安全

2.1、线程安全

2.1.1、代码1

JVM在首次加载java类时，会对静态初始化快、静态成员变量、静态方法进行初始化，从而保证instance只会被初始化一次。

public class SingletonExample{
    
    private SingletonExample(){}

    private static SingletonExample instance = new SingletonExample();

    public static SingletonExample getInstance(){
        return instance;
    }
}

2.1.2、代码2

JVM在首次加载java类时，会对静态初始化快、静态成员变量、静态方法进行初始化，从而保证instance只会被初始化一次。

public class SingletonExample{

    private SingletonExample(){}

    private static SingletonExample instance = null;

    static {
        instance = new SingletonExample();
    }

    public static SingletonExample getInstance(){
        return instance;
    }
}

2.1.3、代码3

使用枚举方式进行实例化，是线程安全的，此种方法也是线程最安全的

public class SingletonExample{

    private SingletonExample(){}

    private 

    private enum Singleton(){
        INSTANCE;
        private SingletonExample singleton;

        // JVM保证这个方法绝对只调用一次
        Singleton(){
            singleton = new SingletonExample();
        }

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

未完待续。。。