欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java通过双重检测或枚举类实现线程安全单例(懒汉模式)

程序员文章站 2022-07-02 18:06:13
双重检测实现 上述为经典的 实现 单例类. 需要注意,如果单例实体 未被 修饰,则 的实现方式 . 从逻辑上, 是正确的,但这是建立在 或者 未对 进行 操作. 将 创建对象分为以下三个步骤执行: 1. 分配对象内存空间; 2. 初始化对象; 3. instance指向分配的内存空间. 在实际的操作 ......

双重检测实现

/**
 * 懒汉模式->双重同步锁单例模式
 */
public class singletonexample5 {

    private singletonexample5() {
    }

    //volatile + 双重检测机制 -> 禁止指令重排序
    private static volatile singletonexample5 instance = null;

    /**
     * synchronized导致性能开销增加
     */
    private static singletonexample5 getinstance() {
        if (null == instance) { //双重检测机制
            synchronized (singletonexample5.class) {    //同步锁
                if (null == instance) {
                    instance = new singletonexample5();
                }
            }
        }
        return instance;
    }
}

上述为经典的双重检测实现java单例类.
需要注意,如果单例实体instance未被volatile修饰,则双重检测的实现方式线程不安全.

从逻辑上,双重检测是正确的,但这是建立在cpu或者jvm未对指令进行重排序操作.
java创建对象分为以下三个步骤执行:

  1. 分配对象内存空间;
  2. 初始化对象;
  3. instance指向分配的内存空间.

在实际的操作过程中,可能发生指令重排序,选择可能场景:执行步骤为1、3、2.
假设有a、b两个线程去执行getinstance

  1. a线程执行完1,3步骤,此时instance非空,但是对象尚未完成初始化操作:
  2. b线程此时访问instance,发现非空,传递给用户使用.
  3. b线程此时拿到的instance实例未完成初始化,后果自行想象.

因此,为了避免cpu或者jvm对指令进行重排序,使用volatile强制避免重排序即可实现线程安全.

tips:getinstance函数可以被synchronized以保证线程安全,但是synchronized在高并发环境下会导致性能损耗严重,因此我们下沉synchronized至函数内部,尽可能缩小同步范围.

枚举类实现

/**
 * 枚举模式:单词调用(需要时构造),线程安全
 */
@slf4j
public class singletonexample7 {

    private singletonexample7() {
    }

    private static singletonexample7 getinstance() {
        return singleton.instance.getinstance();
    }

    private enum singleton {
        instance;

        private singletonexample7 singletonexample7;

        //jvm保证方法只被调用一次
        singleton() {
            try {
                thread.sleep(1000);
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
            log.info("枚举类构造函数运行");
            singletonexample7 = new singletonexample7();
        }

        public singletonexample7 getinstance() {
            return singletonexample7;
        }
    }

    public static void main(string[] args) throws interruptedexception {

        //测试:枚举类实现单例类是否是懒加载
        for (int i = 0; i < 3; i++) {
            log.info("枚举类实现单例");
            thread.sleep(2000);
        }
        system.out.println(getinstance().hashcode());
        system.out.println(getinstance().hashcode());
    }
}

使用枚举类实现线程安全单例,相较于双重检测方式较为简单.
jvm保证枚举类只会被调用一次,构造函数为私有.
此外,实现上述代码可以发现,枚举类实现单例是懒加载模式,只在getinstance时创建并初始化对象.

ps:
如果您觉得我的文章对您有帮助,可以扫码领取下红包,谢谢!
java通过双重检测或枚举类实现线程安全单例(懒汉模式)