懒汉单例模式(double check,静态内部类,枚举的写法)

本文介绍了Java中三种常见的单例模式实现:双检锁(double check)、静态内部类和枚举。每种方式都有其优缺点,如双检锁线程安全但可能导致资源浪费,静态内部类实现线程安全且延迟加载,而枚举则是最安全的单例模式实现,防止反射和序列化破坏单例。通过测试展示了各种情况下的行为。

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

一、double check+synchronized

优点:懒加载(不用不占空间),正常方式获取的对象全局唯一,线程安全。

缺点:一个线程进入同步块,其余线程只能等待,浪费资源;可以使用反射和序列化破坏单例模式

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * test.LazyDoubleCheckSingleton
 * Description:
 * date:3/28/2022 1:41 PM
 *
 * @author:chenweipeng
 * @version:1.0
 * @since JDK 1.8
 */
public class LazyDoubleCheckSingleton<T> implements Serializable{
    //泛型要等到实例化阶段才能被确定,静态变量在类加载过程就已经初始化,加了泛型加载时无法确定类型,所以不能给静态变量加泛型
    private volatile static LazyDoubleCheckSingleton instance;
    //数据存储
    private T data;

    private LazyDoubleCheckSingleton(){}   //私有化构造器,防止类外使用构造器实例化

    public static<T> LazyDoubleCheckSingleton<T> getInstance(Class<T> clazz){   //全局单例获取点
        //检查是否要阻塞
        if (instance == null){
            synchronized (LazyDoubleCheckSingleton.class){
                //检查是否要重新创建实例
                if (instance == null){
                    instance = new LazyDoubleCheckSingleton<T>();
                }
            }
        }
        return instance;
    }

    public T getData() {
        return data;
    }

    public LazyDoubleCheckSingleton<T> setData(T data) {
        this.data = data;
        return this;
    }
}

class Test01{
    public static void main(String[] args) {
        for (int i = 0;i < 100;++i){
            int j = i+1;
            new Thread(()->{
                System.out.println(( "第"+j+"次获取对象的地址"+LazyDoubleCheckSingleton.getInstance(null)));
            }).start();
        }
    }
}

class Test02{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<LazyDoubleCheckSingleton> declaredConstructor = LazyDoubleCheckSingleto
### Java中使用静态内部类实现懒汉单例模式的原因 #### 延迟加载机制 在Java中采用静态内部类的方式可以有效地实现延迟加载。由于外部类对内部类的引用属于被动引用,不属于必须立即初始化的情况之一,因此当加载外部类时并不会同时加载静态内部类。只有在真正需要获取实例的时候才会触发内部类的加载及其对象的创建过程[^1]。 ```java public class Singleton { private Singleton() {} private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return SingletonHolder.INSTANCE; } } ``` 此代码展示了如何利用静态内部类`SingletonHolder`来持有唯一的`Singleton`实例,在调用`getInstance()`之前不会发生任何与实例有关的操作,从而节省资源并提高性能。 #### 线程安全性保障 得益于JVM对于类加载器所施加的一系列同步措施,当首次访问某个尚未被加载过的类或接口时,整个加载、链接到初始化的过程都是原子性的操作。这意味着即使多个线程几乎同时请求同一个未初始化的对象也不会破坏单一实例的原则;即每次只会有一个线程能够成功完成此类构造工作而其他尝试都将等待直至前者结束之后再继续执行下去。 综上所述,通过静态内部类的方式来构建懒汉型单例不仅实现了按需分配内存空间的目的还天然具备良好的并发处理能力,无需额外编写复杂的锁机制就能确保多线程环境下的正常运作。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值