单例懒汉式

本文详细介绍了两种实现线程安全单例模式的方法。方式一利用静态内部类,在类加载时保证唯一实例的创建。方式二采用双重检查锁定模式,结合volatile关键字,确保在高并发环境下单例对象的正确创建。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

#创建一个线程安全单例
##方式一

public class SingletonDemo {
    private SingletonDemo() {
    }

    //jvm在类加载的时候是互斥的,可以保证多线程安全问题
    private static class Singleton {
        private static SingletonDemo singletonDemo = new SingletonDemo();
    }

    public static SingletonDemo getInstance() {
        return Singleton.singletonDemo;
    }
}

##方式二

class Singleton{
    private String str;
    private static volatile Singleton singleton;//第二层锁,volatile关键字禁止指令重排
    private Singleton(){
        str="hello";
    }
    public String getStr() {
        return str;
    }
    public static Singleton getInstance(){
        if(singleton==null){//第一层检查,检查是否有引用指向对象,高并发情况下会有多个线程同时进入
            synchronized (Singleton.class){//第一层锁,保证只有一个线程进入
                //双重检查,防止多个线程同时进入第一层检查(因单例模式只允许存在一个对象,故在创建对象之前无引用指向对象,所有线程均可进入第一层检查)
                //当某一线程获得锁创建一个Singleton对象时,即已有引用指向对象,singleton不为空,从而保证只会创建一个对象
                //假设没有第二层检查,那么第一个线程创建完对象释放锁后,后面进入对象也会创建对象,会产生多个对象
                if(singleton==null){//第二层检查
                    //volatile关键字作用为禁止指令重排,保证返回Singleton对象一定在创建对象后
                    singleton=new Singleton();
                    //singleton=new Singleton语句为非原子性,实际上会执行以下内容:
                    //(1)在堆上开辟空间;(2)属性初始化;(3)引用指向对象
                    //假设以上三个内容为三条单独指令,因指令重排可能会导致执行顺序为1->3->2(正常为1->2->3),当单例模式中存在普通变量需要在构造方法中进行初始化操作时,单线程情况下,顺序重排没有影响;但在多线程情况下,假如线程1执行singleton=new Singleton()语句时先1再3,由于系统调度线程2的原因没来得及执行步骤2,但此时已有引用指向对象也就是singleton!=null,故线程2在第一次检查时不满足条件直接返回singleton,此时singleton为null(即str值为null)
                    //volatile关键字可保证singleton=new Singleton()语句执行顺序为123,因其为非原子性依旧可能存在系统调度问题(即执行步骤时被打断),但能确保的是只要singleton!=0,就表明一定执行了属性初始化操作;而若在步骤3之前被打断,此时singleton依旧为null,其他线程可进入第一层检查向下执行创建对象
                }
            }
        }
        return singleton;
    }
}
### Java懒汉实现 #### 基本概念 Java中的是一种设计模式,用于确保一个类仅有一个实,并提供一个全局访问点。懒汉的特点在于它会在第一次调用时才创建对象实,从而实现了延迟加载[^1]。 #### 懒汉的实现方 以下是懒汉的经典实现方法之一: ```java public class Singleton { private static Singleton instance; // 私有化构造函数,防止外部通过 new 创建实 private Singleton() {} public static synchronized Singleton getInstance() { if (instance == null) { // 第一次判断 instance = new Singleton(); // 创建实 } return instance; } } ``` 此实现方明了,但由于每次调用 `getInstance` 方法都会加锁 (`synchronized`),因此会带来一定的性能开销。为了优化这一点,可以采用双重检查锁定的方。 #### 双重检查锁定(Double-Checked Locking) 为了避免不必要的同步操作并提高性能,可以通过双重检查锁定的方来改进懒汉的实现: ```java public class Singleton { private volatile static Singleton instance; // 使用 volatile 关键字保证可见性和有序性 // 私有化构造函数,防止外部通过 new 创建实 private Singleton() {} public static Singleton getInstance() { if (instance == null) { // 第一次判断 synchronized (Singleton.class) { // 加锁 if (instance == null) { // 第二次判断 instance = new Singleton(); // 创建实 } } } return instance; } } ``` 在此实现中,`volatile` 关键字的作用是确保多个线程能够正确处理 `instance` 的赋值操作,避免指令重排序带来的问题[^2]。 #### 静态内部类实现 除了传统的懒汉实现外,还可以利用静态内部类来实现。这种实现方既保持了线程安全性,又无需显地使用同步机制,因而具有更好的性能表现: ```java public class Singleton { // 定义一个静态内部类,在该类中初始化 private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } // 私有化构造函数,防止外部通过 new 创建实 private Singleton() {} public static Singleton getInstance() { return SingletonHolder.INSTANCE; // 返回 } } ``` 在这种实现中,由于 JVM类加载阶段会对类进行初始化,而静态内部类只有在其被首次使用时才会被加载,因此这种方天然支持懒加载和线程安全。 --- ### 总结 懒汉的核心思想是在需要的时候才创建实,这有助于节省资源。然而,为了确保线程安全,通常需要引入同步机制或其他技术手段。在实际开发中,可以根据具体需求选择适合的实现方。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值