单例模式与多线程（一）

最新推荐文章于 2024-09-20 15:32:13 发布
最新推荐文章于 2024-09-20 15:32:13 发布
阅读量74 收藏
点赞数
文章标签： 单例模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44307209/article/details/126779023
版权

目录

1.立即加载/“饿汉模式”

  什么是立即加载？立即加载就是使用类的时候已经将对象创建完毕，常见的实现方法就是直接new实例化。而立即加载从中文的语境上看，有“着急”、“急迫”的含义，所以也称为“饿汉模式”。
  立即加载/“饿汉模式”是在调用方法前，实例已被创建了。
  创建项目，名称为6.1，创建类MyObject.java代码如下：

public class MyObject {

    //立即加载==饿汉模式
    private static MyObject myObject = new MyObject();
    private MyObject(){
    }
    public static MyObject getInstance() {
        //此代码版本为立即加载
        //此版本代码的缺点是不能有其他实例变量
        //因为getInstance()方法没有同步
        //所以有可能出现非线程安全问题
        return myObject;
    }
}

创建线程类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

创建运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果如下所示：

2046608170
2046608170
2046608170

“饿汉模式”的运行结果

  控制台的打印看到hashcode是同一个值，说明对象是同一个，也就完成我们刚刚所要求的饿汉模式。

2.延迟加载/“懒汉模式”

  什么是延迟加载？延迟加载就是在调用get()方法时实例才被创建，常见的实现方法就是在get()方法的时候进行new实例化。而延迟加载从中文的语境来看，是“缓慢”、“不急迫”的含义，所以也称为“懒汉模式”。

1.延迟加载/“懒汉模式”解析

  延迟加载/“懒汉模式”是在调用方法时实例才被创建。
创建项目6.2.1，创建类MyObject.java代码如下：

public class MyObject {
    private static MyObject myObject;
    private MyObject() {
    }
    public static MyObject getInstance() {
        //延迟加载
        if (myObject != null) {
        } else {
            myObject = new MyObject();
        }
        return myObject;
    }
}

创建线程类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

创建运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

程序运行结果如下所示：

1080578516

“懒汉模式”成功取出一个实例

  此实验虽然取得一个对象的实例，但如果是在多线程的环境中，就会出现取出多个实例的情况，与单例模式的初衷是相背离的。

2.延迟加载/“懒汉模式”的缺点

  前面两个实验虽然使用“立即加载”和“延迟加载”实现了单例设计模式，但在多线程的环境中，前面“延迟加载”示例中的代码完全就是错误的，根本不能实现保持单例的状态。来看一下如何在多线程环境中结合“错误的单例模式”创建出“多例”。
创建项目6.2.2，创建类MyObject.java代码如下：

public class MyObject {
    private static MyObject myObject;
    private MyObject() {
    }
    public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                //模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }
}

创建线程类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

创建运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

程序运行结果如下所示：

35859381
943931288
35859381

非单例设计模式

  控制台打印出了3种hashCode，说明创建出了3个对象，并不是单例的，这就是“错误的单例模式”。

3.延迟加载/“懒汉模式”的解决方案

（1）声明synchronized关键字

  既然多个线程可以同时进入getInstance（）方法，那么只需要对getInstance（）方法声明synchronized关键字即可。
创建项目6.2.3-1，创建类MyObject.java代码如下：

public class MyObject {
    private static MyObject myObject;
    private MyObject() {
    }
    // 设置同步方法效率太低了
    // 整个方法被上锁
    synchronized public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                // 模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }
}

创建线程类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

创建运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

程序运行结果如下所示：

569219718
569219718
569219718

  此方法加入同步synchronized关键字得到相同实例的对象，但此种方法的运行效率非常低下，是同步运行的，下一个线程想要取得对象，则必须等上一个线程释放锁之后，才可以继续执行。

（2）尝试同步代码块

  同步方法是对方法的整体进行持锁，这对运行效率来讲是不利的。
创建项目6.2.3-2，创建类MyObject.java代码如下：

public class MyObject {
    private static MyObject myObject;
    private MyObject() {
    }
    public static MyObject getInstance() {
        try {
            // 此种写法等同于：
            // synchronized public static MyObject getInstance()
            // 的写法，效率一样很低，全部代码被上锁
            synchronized (MyObject.class) {
                if (myObject != null) {
                } else {
                    // 模拟在创建对象之前做一些准备性的工作
                    Thread.sleep(3000);
                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }
}

创建线程类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

创建运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
        //此版本代码虽然是正确的
        //但public static MyObject getInstance()方法
        //中的全部代码都是同步的了，这样做也会降低运行效率
    }
}

程序运行结果如下所示：

1674612146
1674612146
1674612146

  此方法加入同步synchronized语句块得到相同实例的对象，但这种方法的运行效率也是非常低的，和synchronized同步方法一样是同步运行的。

（3）针对某些重要的代码进行单独的同步

  同步代码块可以针对某些重要的代码进行单独的同步，而其他的代码则不需要同步。这样在运行时，效率完全可以得到大幅提升。
创建项目6.2.3-3，创建类MyObject.java代码如下：

public class MyObject {
    private static MyObject myObject;
    private MyObject() {
    }
    public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                // 模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                // 使用synchronized (MyObject.class)
                // 虽然部分代码被上锁
                // 但还是有非线程安全问题
                synchronized (MyObject.class) {
                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }
}

创建线程类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

创建运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}

程序运行结果如下所示：

263494223
239871018
1662354276

  此方法使同步synchronized语句块，只对实例化对象的关键代码进行同步，从语句的结构上来讲，运行的效率的确得到了提升但如果是遇到多线程的情况下还是无法解决得到同一个实例对象的结果。

（4）使用DCL双检查锁机制

  在最后的步骤中，使用的是DCL双检查锁机制来实现多线程环境中的延迟加载单例设计模式。
创建项目6.2.3-4，创建类MyObject.java代码如下：

public class MyObject {
    private volatile static MyObject myObject;
    private MyObject() {
    }
    // 使用双检测机制来解决问题，既保证了不需要同步代码的异步执行性
    // 又保证了单例的效果
    public static MyObject getInstance() {
        try {
            if (myObject != null) {
            } else {
                //模拟在创建对象之前做一些准备性的工作
                Thread.sleep(3000);
                synchronized (MyObject.class) {
                    if (myObject == null) {
                        myObject = new MyObject();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }
    // 此版本的代码称为双重检查Double-Check Locking
}

创建线程类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(MyObject.getInstance().hashCode());
    }
}

创建运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
    }
}
//使用双重检查锁功能，成功地解决了“懒汉模式”遇到读哦现场

程序运行结果如下所示：

38472714
38472714
38472714

  使用双重检查锁功能，成功地解决了“懒汉模式”遇到多线程的问题。DCL也是大多数多线程结合单例模式使用的解决方案。


以上代码下载请点击该链接：https://github.com/Yarrow052/Java-package.git

Yarrow-Y
关注
Java多线程实战之单例模式与多线程的实例详解
08-26
Java多线程实战之单例模式与多线程的实例详解 单例模式是Java多线程编程中最常用的设计模式之一，它的主要作用是确保一个类在应用程序中只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，如饿汉模式、...
QT单例模式、多线程、双重校验加锁
06-11
在QT中，单例模式、多线程以及双重校验加锁（Double-Checked Locking）是常见的编程模式和技术，尤其在处理并发和资源管理时显得尤为重要。 **单例模式** 是一种设计模式，确保一个类只有一个实例，并提供一个全局...
单例模式与多线程
一线工作者的所见、所闻......
11-13 1万+
一、前言 如何使单例模式遇到多线程是安全的、正确的？ 我们在学习设计模式的时候知道单例模式有懒汉式和饿汉式之分。简单来说，饿汉式就是在使用类的时候已经将对象创建完毕，懒汉式就是在真正调用的时候进行实例化操作。 二、饿汉式+多线程 单例： public class MyObject { //饿汉模式 private static MyObject...
C++｜设计模式（一）｜单例模式与多线程
糖炒栗子
05-20 1119
本文讲解重点在线程安全的懒汉式单例模式。
【多线程】单例模式
weixin_62848751的博客
07-25 1327
单例模式是一种经典的设计模式它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。单例模式主要用于控制对某些共享资源的访问，例如配置管理器、连接池、线程池、日志对象等。
C++单例模式与多线程安全
PPprogrammer的博客
01-23 1955
用代码实现如下： class Singleton { public: static Singleton* CreateObj() { if (m_pInstance == NULL) { m_pInstance = new Singleton(); } return m_pInstance; } void test() { cout << "访问单例类的接...
彻头彻尾理解单例模式与多线程
杜海的博客
06-08 522
摘要： 　　 　　本文首先概述了单例模式产生动机，揭示了单例模式的本质和应用场景。紧接着，我们给出了单例模式在单线程环境下的两种经典实现：饿汉式和懒汉式，但是饿汉式是线程安全的，而懒汉式是非线程安全的。在多线程环境下，我们特别介绍了五种方式来在多线程环境下创建线程安全的单例，使用synchronized方法、synchronized块、静态内部类、双重检查模式和ThreadLocal实现懒汉式单例，并总结出实现效率高且线程安全的单例所需要注意的事项。 ...
【大话设计模式】模式一 ：单例模式与多线程
m0_46013789的博客
01-19 1450
一、基本介绍 单例模式（Singleton），保证一个类仅仅有一个实例，并且提供一个访问它的全局访问点。 通常我们可以让一个全局变量使其被一个对象访问，但是它不能防止实例化多个对象。最好的方法就是，让类自身负责保存它的唯一实例，同时这个类保证没有其他实例可以被创建，并且它提供了一个访问该实例的方法。​​​ 模式构成要素： 私有构造方法 私有静态引用指向自己的实例 以自己实例为返回值的公有静态方法 二、模式应用场景及举例 1、适用场景：1.需要生成唯一序列的环境。 2.需要频繁实例化然后销毁
c++ 单例模式与多线程
师范大学生的博客
05-31 2346
单例模式   单例模式的概念比较简单，即某一类只能创建一个对象，这样设计类的方式就是单例模式。   在直接看代码之前，可以稍微思考一下这个单例模式大概会是个什么情况。   在C++中，调用一次构造函数就会创建一个对象，这个机制是货真价实的，因此也可以推测出，单例模式某种程度上实现了构造函数的“隐藏”。   构造函数怎么藏这个具体想不到，不过大致能想出来一个点，应该将构造函数放在private区域内，令其属于类的私有成员，这样在对象中（类的区域之外）就不能直接调用构造函数了。如果不这样做，构造函数天天露在外面
单例模式以及线程安全问题
m0_74173529的博客
04-04 1032
单例模式以及解决线程安全问题
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
设计模式：单例模式-单例模式与多线程、堵塞的关系
Aisnice的博客
12-10 874
单例模式与多线程、堵塞并无直接关系，是否堵塞与方法中是否需要竞争同步资源有关系，否则多线程调用单例模式的情况下线程间互不影响
详解python实现线程安全的单例模式
09-20
总结来说，Python实现线程安全的单例模式通常需要结合装饰器和线程锁来确保在多线程环境下只有一个实例存在。这里的实现方式是定义了两个装饰器，`Singleton`用于创建单例，`synchronized`用于实现线程同步。通过...
Java 单例模式线程安全问题
08-29
然而，在多线程环境下，单例模式可能会遇到线程安全问题，因为多个线程可能会同时访问同一个实例，从而导致数据不一致和其他问题。 在 Java 中，单例模式的实现可以使用双重检查锁机制、静态内部类和枚举类型等方式...
Qt：实现单例模式
m0_71489826的博客
09-17 1507
记录一下。
【JavaEE初阶】多线程(5 单例模式 \ 阻塞队列)
2301_80898480的博客
09-17 879
如有错误，欢迎指出~
Java-网络
2301_81543552的博客
09-14 802
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 843
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 343
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java单例模式与多线程深度解析
"Java单例模式与多线程总结归纳" 在Java编程中，单例模式是一种常用的设计模式，它的核心在于确保一个类只有一个实例，并提供一个全局访问点。单例模式的应用广泛，如线程池、缓存、日志系统、对话框等，其目的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值