线程安全的单例模式

最新推荐文章于 2025-07-06 20:41:22 发布
原创 最新推荐文章于 2025-07-06 20:41:22 发布 · 322 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #多线程

单例设计模式之旅

  • 单例设计模式应用场景
  • 如何实现单例设计模式
  • 懒汉设计模式线程安全

1. 单例模式的应用场景

(1).单例模式就是类在程序运行的过程中只创建一个对象，同时该类会提供一个可以在全局范围内访问这个对象的static方法并且私有化该类的构造器,这个静态方法通常为命名为getInstance()。

(2).单例模式可以根据创建对象的时间分为饿汉模式和懒汉模式。如果一个类的实例在项目启动时不管使用不使用就被预先创建则称这种单例模式为饿汉模式；如果一个类的实例在启动时不预先创建而是在第一次调用时创建则称这种单例模式为懒汉模式.

(3).饿汉模式的优点是立即创建实例在首次调用时会节省时间，缺点是会延长项目启动的时间。懒汉模式优点是会节省项目启动的时间；缺点是会在首次调用时耗费时间，使用不当会出现线程安全问题。

(4).总结:通常饿汉模式用于较小的项目中,懒汉模式用于较大的项目中。两者的特点说明时间和空间是不可以兼得的。

2. 单例模式的实现案例

package csdn.qiang;
/**
 * 单例模式之饿汉模式
 */
public class SingletonA {
    private static SingletonA singleton = new SingletonA();
    private SingletonA(){}//私有化构造器防止外部创建对象
    public static SingletonA getInstance(){
        return singleton;
    }
    public static void main(String[] args) {//验证
        Thread t1 = new Thread(()->{
            System.out.println(
                SingletonA.getInstance().hashCode()
            );
        });
        Thread t2 = new Thread(()->{
            System.out.println(
                SingletonA.getInstance().hashCode()
            );
        });
        Thread t3 = new Thread(()->{
            System.out.println(
                SingletonA.getInstance().hashCode()
            );
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

这里写图片描述

上面的运行结果表明：在三个不同的线程中获取的是同一个对象。


package csdn.qiang;
/**
 * 典型错误:单例模式之懒汉模式
 */
public class SingletonB {
    private static SingletonB singleton = null;
    private SingletonB(){}//私有化构造器防止外部创建对象
    public static SingletonB getInstance(){
        if(singleton==null)
            singleton = new SingletonB();
        return singleton;
    }
    public static void main(String[] args) {//验证
        Thread t1 = new Thread(()->{
            System.out.println(
                SingletonB.getInstance().hashCode()
            );
        });
        Thread t2 = new Thread(()->{
            System.out.println(
                SingletonB.getInstance().hashCode()
            );
        });
        Thread t3 = new Thread(()->{
            System.out.println(
                SingletonB.getInstance().hashCode()
            );
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果

这里写图片描述

上面的运行结果表明：在三个不同的线程中获取的是同一个对象。表面上看，这三个线程确实是获取了同一个对象，其实，这样写是有bug的，只是在这里没有表现出来。没有表现出来的原因是三个线程去获取对象时在时间上具有一定的先后顺序，即当第一个线程创建并获取对象后其它线程才来获取对象发现对象已经被创建，这样后来的线程就直接获取对象就可以了而不需要去创建对象，这样三个线程获取的就是同一个对象了。

package csdn.qiang;

import java.util.concurrent.TimeUnit;
/**
 * 错误展示:单例模式之懒汉模式
 */
public class SingletonC {
    private static SingletonC singleton = null;
    private SingletonC(){}//私有化构造器防止外部创建对象
    public static SingletonC getInstance() 
        throws  InterruptedException{
            if(singleton==null){
                TimeUnit.SECONDS.sleep(3);
                singleton = new SingletonC();
            }
            return singleton;
    }
    public static void main(String[] args) 
        throws InterruptedException {//懒汉模式的验证
            Thread t1 = new Thread(()->{
                try {
                    System.out.println(
                        SingletonC.
                            getInstance().hashCode()
                    );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });

            Thread t2 = new Thread(()->{
                try {
                    System.out.println(
                        SingletonC.
                            getInstance().hashCode()
                    );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });

            Thread t3 = new Thread(()->{
                try {
                    System.out.println(
                        SingletonC.
                            getInstance().hashCode()
                    );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

这里写图片描述

上面的运行结果表明：多个线程在访问同一个资源的时机往往是不确定的，并不能保证多个线程在需要获取对象时对象都经被创建。可能出现的情况是多个线程都来访问同一个对象，但是该对象并没有被创建,这样每一个线程都会主动去创建一个对象。这样就不能保证每一个线程获取的都是同一个对象。

3.懒汉模式线程安全
(1).相对低效的懒汉模式(粗颗粒度的synchronized)

package csdn.qiang;

import java.util.concurrent.TimeUnit;
/**
 * 相对低效且线程安全的懒汉模式
 */
public class SingletonD {
    private static SingletonD singleton = null;
    private SingletonD(){}//私有化构造器防止外部创建对象
    public synchronized static SingletonD 
        getInstance() throws InterruptedException{
        //使用synchronized锁定SingletonD.class
        if(singleton==null){
            TimeUnit.SECONDS.sleep(3);
            singleton = new SingletonD();
        }
        return singleton;
    }
    public static void main(String[] args) 
        throws InterruptedException {//懒汉模式的验证
        Thread t1 = new Thread(()->{
            try {
                System.out.println(
                    SingletonD.getInstance().hashCode()
                );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(()->{
            try {
                System.out.println(
                    SingletonD.getInstance().hashCode()
                );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(()->{
            try {
                System.out.println(
                    SingletonD.getInstance().hashCode()
                );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

这里写图片描述

上面的运行结果表明：当前的单例模式的实现在多线程的情况下是正确的。但是，这里使用了synchronized关键字实现同步方法，其实往往很多时候我们要同步的代码只有那么关键的几句，如果将整个方法都进行同步会降低程序的执行效率。因此不建议这样使用。

(2).相对高效的懒汉模式(细颗粒度的synchronized)

package csdn.qiang;

import java.util.concurrent.TimeUnit;
/**
 * 相对高效且线程安全的懒汉模式
 *           --双检查锁机制
 */
public class SingletonE {
    private static SingletonE singleton = null;
    private SingletonE(){}//私有化构造器防止外部创建对象
    public  static SingletonE getInstance() 
        throws InterruptedException{
        if(singleton==null){
            TimeUnit.SECONDS.sleep(3);
            synchronized(SingletonE.class){
                //使用synchronized锁定SingletonD.class
                if(singleton==null){
                    singleton = new SingletonE();
                }
            }
        }
        return singleton;
    }
    public static void main(String[] args) throws InterruptedException {//懒汉模式的验证
        Thread t1 = new Thread(()->{
            try {
                System.out.println(
                    SingletonE.getInstance().hashCode()
                );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(()->{
            try {
                System.out.println(
                    SingletonE.getInstance().hashCode()
                );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(()->{
            try {
                System.out.println(
                    SingletonE.getInstance().hashCode()
                );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

这里写图片描述

上面的运行结果表明：当前的单例模式的实现在多线程的情况下是正确的。这里使用了synchronized关键字实现同步代码块，并且使用了双检查机制。这样使用的优点是可以使既能保证核心代码的同步执行，又能获得相对较高的执行效率。

Python中的线程安全单例模式实现详解
windowshht的博客
05-16 1023
然而，在多线程环境下，如果不进行适当的同步，可能会导致多个线程同时创建实例，从而破坏单例模式的初衷。除了上述两种方法外，还有其他一些实现线程安全单例模式的技巧，比如使用装饰器（decorator）来封装单例的创建过程，或者使用Python的元类（metaclass）来动态地修改类的创建行为。但是，如果需要在类的构造函数中执行一些复杂的初始化操作，或者需要更精细地控制实例的创建和销毁过程，那么使用。Python的模块在导入时是线程安全的，这意味着如果我们将单例实例保存为模块级变量，则可以自动实现线程安全。
线程安全单例模式：Python中的实现与应用
windowshht的博客
06-04 592
确保一个类只有一个实例：无论多少次请求，只有一个实例被创建。提供一个全局访问点：可以通过这个点访问类的唯一实例。
Java 实战：无锁方式实现高性能线程安全单例
最新发布
java_beautiful的博客
07-06 895
实现方式线程安全延迟加载防反射攻击防反序列化性能(百万次/秒)实现复杂度JDK 要求适用场景静态内部类✓✓✗(可添加)✗(需添加方法)30-37低1.2+大多数场景，尤其是需要延迟加载的情况枚举方式✓✗✓✓32-38最低1.5+需要防止反射和序列化攻击的场景CAS 方式✓✓✗✗22-35中1.5+极高并发且对锁敏感的场景双重检查锁✓✓✗✗20-34中1.5+需要延迟加载且初始化过程复杂的场景分布式实现✓视情况✗。
<转>单例模式 线程安全
i54fx的专栏
04-28 202
线程安全性的定义： 如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 　　或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。 线程安全问题都是由全局变量及静态变...
Qt线程安全单例模式写日志模式
09-20
保证一个类只有一个实例，并提供一个访问它的全局访问点，使得系统中只有唯一的一个对象实例，具有线程安全，多线程测试通过。 1.打开日志并创建日志文件夹 默认为程序启动路径 2.清理日志文件下日志数量 默认保留90...
老生常谈C++的单例模式与线程安全单例模式(懒汉/饿汉)
12-25
1 教科书里的单例模式 我们都很清楚一个简单的单例模式该怎样去实现：构造函数声明为private或protect防止被外部函数实例化，内部保存一个private static的类指针保存唯一的实例，实例的动作由一个public的类方法...
写一个线程安全的单例模式
sdywcd——jshoper3x开源商城系统作者
04-08 168
谢谢 http://blog.sina.com.cn/s/blog_75247c770100yxpb.html 的作者   深入浅出下 public class SingleA{ private static class SingleHolder{ public final static SingleA instance=new SingleA(); ...
线程安全之单例模式
小司机的奥拓
04-17 1170
这篇文章,我们会介绍一下单例模式,但这里的单例模式,不是我们所说的设计模式,当然听到设计模式,大家一定都说,我当然知道设计模式了,有23种呢?一下子一顿输出,当然我这里说的单例模式还是跟设计模式有一些区别的,当然我不做概述,因为我也没咋个去了解过设计模式,我把大家拉回来,什么是多线程对的单例模式呢?看完我以下的解释相信你会明白的.多线程环境下的单例模式需要保证只有一个实例对象被创建，并且可以在多线程环境下安全地访问该实例。
关于线程安全的单例模式
ww464214415的博客
05-11 301
这是我写的第一篇博客请大家多多支持，如果有写的不对的地方，欢迎大家指正批评！今天和同事做公交车的时候，同事突然问了一下我单例模式，我说这有什么不会写的，但是同事又问了线程安全的单例模式，我也会写但是一问我问什么是安全的，我突然有点蒙，不知道怎么答，故而查了一下资料记录一下 1 //双重检查锁 2 public final class DoubleCheckedSingleton 3 { ...
一个线程安全的单例模式
小野爸爸的博客
06-17 235
/** * @author lhj * @Description: 一个线程安全的单例模式 * @date 2019/6/17 19:32 */ public class SingletonSafe { //私有化构造方法 private SingletonSafe(){ } //私有化一个静态的单例对象 //volatile的目的是防止JVM指...
线程安全单例模式
weixin_49258031的博客
08-03 235
本文主要介绍java的单例模式，以及详细剖析静态内部类之所以能够实现单例的原理。OK，废话不多说，进入正文。 首先我们要先了解下单例的四大原则： 1.构造私有。 2.以静态方法或者枚举返回实例。 3.确保实例只有一个，尤其是多线程环境。 4.确保反序列换时不会重新构建对象。 我们常用的单例模式有： 饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式，我们来逐一分析下这些模式的区别。 1.饿汉模式： public class SingleTon{ private static SingleTon I
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值