单例模式之懒汉的并发问题，只需要添加一个 synchronized 就可以解决了

最新推荐文章于 2022-11-04 22:23:08 发布
原创 最新推荐文章于 2022-11-04 22:23:08 发布 · 1.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

该博客讨论了在并发环境中懒汉式单例模式可能遇到的问题，通过实例展示了当多个线程同时调用 getInstance 方法时，可能导致多次实例化。博主提出，只需在 getInstance 方法上添加 synchronized 关键字，即可确保线程安全，实现单例的正确创建。

复现并发问题：

package review.bank;

/**
 * Created by kodulf on 2017/2/26.
 */
public class SingleInstanceLazyMan {

    private SingleInstanceLazyMan(){

    }

    static SingleInstanceLazyMan singleInstanceLazyMan ;

    //synchronized 如果不添加，那么会出现三个进程一起调度的情况
    public static SingleInstanceLazyMan getInstance(){
        if(singleInstanceLazyMan==null){
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());

            singleInstanceLazyMan = new SingleInstanceLazyMan();

            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());

        }

        return singleInstanceLazyMan;
    }

}


新建三个进程去调用这个单例的getInstance方法

    public static  void testSingleInstance(){
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstanceLazyMan.getInstance();
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstanceLazyMan.getInstance();
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstanceLazyMan.getInstance();
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }


运行结果：会发现都调用了if == null的那个判断了，就是执行了里面的程序了

before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-0
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2

Process finished with exit code 0


要解决这个问题：

只需要添加一个单词，synchronized 就可以了

package review.bank;

/**
 * Created by zhangyinshan on 2017/2/26.
 */
public class SingleInstanceLazyMan {

    private SingleInstanceLazyMan(){

    }

    static SingleInstanceLazyMan singleInstanceLazyMan ;

    //synchronized 如果不添加，那么会出现三个进程一起调度的情况
    public static synchronized SingleInstanceLazyMan getInstance(){
        if(singleInstanceLazyMan==null){
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());

            singleInstanceLazyMan = new SingleInstanceLazyMan();

            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());

        }

        return singleInstanceLazyMan;
    }

}


运行结果：只调用了一次，这个就是我们想要的

before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0

Process finished with exit code 0






【JavaEE】单例模式：饿汉模式与懒汉模式，解决懒汉模式线程不安全问题
weixin_71246590的博客
05-27 1019
前言：在软件开发中，有时我们需要确保一个类在内存中只存在一个实例，这不能只靠程序猿人为保证只创建了一个实例，而需要通过编程技巧约束，让我们只能创建一个实例。这可以通过单例模式（Singleton Pattern）来实现。在本文中，我们将探讨单例模式的两种主要实现方式：饿汉模式和懒汉模式，以及懒汉模式引发的线程安全问题。
【JUC】深入解析 JUC 并发编程：单例模式、懒汉模式、饿汉模式、及懒汉模式线程安全问题解析和使用 volatile 解决内存可见性问题与指令重排序问题
最新发布
OuO-1 的博客
05-30 2083
单例模式、懒汉模式、饿汉模式、及懒汉模式出现的线程安全问题、使用 volatile 解决内存可见性问题、指令重排序问题的原理
单例懒汉式的并发访问
weixin_30767835的博客
02-01 127
饿汉式没有并发问题，因为没有执行多条语句。（并发安全问题是由两个条件产生的：1、线程任务中在操作共享的数据； 2、线程任务操作共享数据的代码有多条）懒汉式并发访问会有安全隐患，所以加入同步机制解决安全问题。 class Single { 　　private static Single s = null ; 　　private Single (){} 　　public stat...
单例 懒汉式且使用 synchronized
dickzhu的专栏
03-25 382
[code="java"] package com.statestr.gcth.application.dao.impl; public class LazySingleton { private LazySingleton(){ } public synchronized static LazySingleton obtainInstance(){ ...
01-单列模式 [懒汉式 线程安全 synchronized同步方法]
明天会为今天的努力而感到骄傲！
08-01 458
package com.design.patterns; /** * 懒汉式加载 线程安全 * 1.将类构造器私有化，防止new对象 * 2.创建静态常量 * 3.提供公共获取对象的方法(同步方法)，只不过需要判断类对象是否为空，如果对象为空则进行创建对象，否则直接返回 */ public class LazyLoadDemo_ThreadSafe { public static void main(String[] args) { LazySafeSingleton lazyNotS.
单例模式＋synchronized的学习
cuihaoren01的专栏
03-25 662
Java线程同步学习
【synchronized关键词】高并发下地单例模式
扬帆舟的博客
12-12 844
单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。 通常单例模式会这样写： package cn.com.test.p201612.test3; public class MemcachedUtil { private static MemcachedUtil instance
精选资源
Java多线程-解决单例模式中的懒汉式的线程安全问题
02-01
### Java多线程—解决单例模式中的懒汉式的线程安全问题 #### 一、单例设计模式的线程安全问题 ##### （1）饿汉式没有线程安全问题 **饿汉式**是一种非常典型的单例模式实现方式，其特点是在类加载时就完成了实例...
完美解决单例设计模式中懒汉式线程安全的问题
08-31
单例设计模式是一种常见的软件设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。在Java中，懒汉式单例是延迟初始化单例，即只有在第一次使用时才会创建实例，这样可以节省资源。然而，懒汉式单例在多...
单例模式，懒汉模式和饿汉模式
07-13
单例模式是软件设计模式中的一种，用于控制类的实例化过程，确保一个类在整个程序运行期间只有一个实例存在。这种模式常用于管理共享资源，如数据库连接、缓存或者线程池等，以减少资源消耗并提高性能。单例模式有...
并发编程——设计模式之单例模式
u014112521的专栏
02-08 967
7中单例模式设计 懒汉式、饿汉式、饿汉式+同步、double-check、double-check+volatile、holder以及枚举方式创建单例模式
Singleton单例模式-【懒汉式-加双重校验锁&防止指令重排序的懒汉式】实现方案中为什么需要加volatile关键字
明月专栏
04-09 2355
前提知识点：volatile可以保证可见性+防止指令重排序，synchronized可以保证可见性+防止指令重排序+原子性。 也即是说volatile是synchronized的功能子集，我们知道在【懒汉式-加双重校验锁】的单例模式实现中已经使用了synchronized关键字，那为什么还需要加volatile关键字呢 回顾【懒汉式-加双重校验锁&防止指令重排序的懒汉式】 public...
单例模式之懒汉式（三种代码实现）
CharmingC1的博客
08-24 2897
单例模式之懒汉式（三种代码实现）
【javaEE】——synchronized使用和单例模式（线程安全）03
qq_45864756的博客
11-04 2590
关于线程学习的一些基础编程知识，和快速入门必学
创建型设计模式（一）-单例模式简述及优化
张井天的博客
11-30 644
一、前言： 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证并发环境下中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。 常见的单例模式： 饿汉模式： 在程序启动时即创建对象实例。 懒汉模式：仅当程序中使用到改对象时，才回去创建对象。 二、单例模式实例： 1. 饿汉模式，程序启动，对象实例被创建 【不推荐】： /** * @...
API基础训练第十天
dyr_080508的博客
02-17 357
API基础训练第十天
单例模式：饿汉模式+懒汉模式
柠檬精
11-23 456
什么是单例模式：一个类只允许产生一个实例化对象 特点：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得对象实例化 首先构造方法私有化就外部无法产生新的实例化对象，所以就只能在类的内部进行实例化 private Singleton singleton=new Singleton(); 但是此时singleton对象是一个普通的属性，所有的普通属性必须要在实例化对象的时候再能进行内存空间的分配，而现在外部是无法进行实例化对象的，所以必须想一个办法，可以在Singleto...
关于单例模式懒汉式的线程安全问题，synchronized，volatile的使用
Jarbein的博客（Java军师公众号）
10-11 1385
首先将正确代码放出来 同时说明一下，到单例模式的饿汉式加载是线程安全的，因为一开始就已经将唯一的对象创建好了，调用时只要返回就行了 以上是一个正确的线程安全的懒汉式写法，这里主要讲两个知识点，一个是synchronized代码块的作用，一个是volatile的作用。 java内存模型（JMM） synchronized如何做到可见性 如果没有加synchronized代码块，那么可能多个线程...
Java懒汉式单例模式中synchronized多种使用方法的比较
weixin_46049575的博客
11-03 394
单例模式---> 懒汉式 public class Student { private static Student instance = null; private Student() {} /** * 双重检索方式（效率最高） * * Thread-1---->com.online.taxi.order.service.impl.Student@22047bda * Thread-0---->com.onl...
深入解析单例模式：并发问题与无锁解决方案
本文档深入探讨了单例模式的实现机制以及在并发环境中的问题和解决方案。单例模式是一种常用的设计模式，它确保一个类只有一个实例，并提供全局访问点。本文主要关注三种实现方式： 1. **标准单例模式（Simple ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值