Java单例模式的懒汉式和饿汉式的实现

川长思鸟来 2022-12-06 04:17 75阅读 0赞

懒汉模式：

/**
     * @author baikunlong
     * @date 2020/9/12 9:20
     * 单例模式1 懒汉模式
     */
    public class Single1 {
        //加上volatile关键字，解决双重检测的超小几率翻车，达到百分百单例
        private static volatile Single1 single1;
    
        //构造器改成私有，防止外部调用
        private Single1() {
        }
    
        public static Single1 getSingle1() {
            if (single1 == null) {
                synchronized (Single1.class) {
                    //使用双重检查，解决了在方法体加同步锁带来的效率低下问题，这样只有当single1为空时那几个线程会进来
                    if (single1 == null) {
                        System.out.println("实例对象");
                        // single1 = new Single1();这一句是非原子操作，JVM会执行三个步骤
                        //1 给single1分配内存
                        //2 调用构造器初始化成员变量，形成实例
                        //3 将single1对象指向分配的内存（这步执行完就是非null）
                        //这三个步骤顺序是不能保证的，所以可能执行了3，2还没执行，其他线程就会直接拿到single1了（但是还没初始化），就会报错了
                        //解决办法就是实例对象加上volatile关键字，volatile关键字的⼀个作⽤是禁⽌指令重排，把single1声明为volatile之后，对它的写操作就会有⼀个内存屏障（什么是内 存屏障？），这样，在它的赋值完成之前，就不⽤会调⽤读操作。
                        //注意：volatile阻⽌的不是singleton = new Singleton() 这句话内部[1-2-3]的指令重排，⽽是保证了在⼀个写操作（[1-2-3]）完成之前，不会调⽤读操作（if (single1 == null)）。
                        single1 = new Single1();
                        System.out.println(single1);
                    }
                }
            }
            return single1;
        }
    
        public static void main(String[] args) {
            for (int i = 0; i < 10000; i++) {
                new Thread(() -> {
                    getSingle1();
                }).start();
            }
        }
    }

普通版饿汉模式：

/**
     * @author baikunlong
     * @date 2020/9/12 10:14
     * 饿汉式的实现一
     */
    public class Single2 {
        private static final Single2 single=new Single2();
        private Single2(){}
        public static Single2 getSingle2(){
            return single;
        }
    }

加强版饿汉模式：

/**
     * @author baikunlong
     * @date 2020/9/12 10:14
     * 饿汉式的实现二
     */
    public class Single3 {
        //对于内部类来说，它是饿汉式模式，在SingletonHolder初始化的时候会由ClassLoader来保证同步，使single3是⼀个真单例。
        //由于是内部类，只有当外部调用getSingle3时，才会初始化实例，则对外部来说这是一个懒汉式
        private static class SingletonHolder{
            private static final Single3 single3=new Single3();
        }
        private Single3(){}
        public static Single3 getSingle3(){
            return SingletonHolder.single3;
        }
    }