多线程03

原创 于 2026-09-09 09:30:08 发布 · 240 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

目录

Java 多线程：线程安全、wait/notify 与单例模式详解

一、线程安全问题

1. 什么是线程安全？

2. 线程安全问题产生的原因

（1）线程的随机调度

（2）多个线程修改同一个变量

（3）操作不是原子的

（4）内存可见性问题

（5）指令重排序

二、wait 与 notify

wait 与 join 的区别

join

wait

锁竞争问题

三、线程饥饿（Starvation）

四、wait 方法详解

1. 当前线程进入等待状态

2. 释放当前持有的锁

注意事项

wait 和 synchronized 必须使用同一个锁对象

五、单例设计模式

什么是设计模式

什么是单例模式

六、饿汉模式

七、懒汉模式

7.1 普通懒汉模式（线程不安全）

7.2 同步方法

7.3 双重检查锁（DCL）

7.4 为什么需要 volatile

总结

Java 多线程：线程安全、wait/notify 与单例模式详解

一、线程安全问题

1. 什么是线程安全？

线程安全指的是：

一段代码在多线程环境下运行时，无论线程如何调度，程序最终都能够得到符合预期的结果。

例如：

count++;

假设两个线程同时执行这行代码。

我们的预期是：

count = count + 2;

但最终结果可能只增加了 1。

这说明程序出现了线程安全问题。

2. 线程安全问题产生的原因

（1）线程的随机调度

线程由操作系统负责调度。

现代操作系统普遍采用抢占式调度：

  • 当前线程运行过程中可能随时被暂停；

  • CPU 可能切换到其他线程执行；

  • 程序员无法预测线程切换时机。

因此，多线程执行顺序是不确定的。

（2）多个线程修改同一个变量

当多个线程同时读写同一个变量时，就可能产生数据竞争（Race Condition）。

例如：

count++;

表面上看是一条语句，但实际上对应多个CPU指令：

读取 count
count + 1
写回 count

如果两个线程同时执行，就可能出现：

线程A读取 count = 0
线程B读取 count = 0

线程A写回 1
线程B写回 1

最终结果变成：

count = 1

而不是预期的：

count = 2

（3）操作不是原子的

原子性（Atomicity）指：

一个操作要么全部执行成功，要么完全不执行，中间不会被其他线程打断。

例如：

count++;

并不是原子操作。

因为它对应：

读取
计算
写回

三个步骤。

在执行过程中可能被其他线程插入执行，从而导致线程安全问题。

（4）内存可见性问题

为了提高运行效率，CPU 和编译器会进行优化。

线程读取变量时：

boolean flag = false;

可能不会每次都从主内存读取，而是缓存到自己的工作内存中。

此时：

线程A：

while(!flag){
}

线程B：

flag = true;

虽然线程B已经修改了变量，

但线程A可能一直读取自己缓存中的旧值。

导致循环无法结束。

这就是内存可见性问题。

解决方案：

volatile boolean flag;

volatile能够保证变量修改后立即刷新到主内存，并保证其他线程能够及时看到最新值。

（5）指令重排序

为了提高执行效率：

编译器和CPU可能调整指令执行顺序。

例如：

new Singleton();

理论执行过程：

1. 申请内存
2. 初始化对象
3. 引用指向对象

实际可能被优化为：

1. 申请内存
2. 引用指向对象
3. 初始化对象

此时其他线程可能拿到一个尚未初始化完成的对象。

这就是指令重排序问题。

二、wait 与 notify

wait 和 notify 用于协调多个线程之间的执行顺序。

它们无法决定CPU调度哪个线程，

但能够让线程主动进入等待状态。

例如：

线程A先执行
线程B等待

线程A完成后
唤醒线程B

这样就实现了线程之间的协作。

wait 与 join 的区别

join

t1.join();

含义：

当前线程必须等待 t1 完全执行结束。

wait

lock.wait();

含义：

当前线程等待其他线程调用 notify() 或 notifyAll()。

不要求对方线程结束运行。

因此：

join：等待线程结束

wait：等待线程被唤醒

锁竞争问题

多个线程竞争同一把锁时：

synchronized(lock){
}

锁释放后：

哪个线程获得锁是不确定的。

例如：

A获得锁
A释放锁

下一次：
可能B获得锁
也可能A再次获得锁

完全由操作系统调度决定。

三、线程饥饿（Starvation）

线程饥饿指：

某个线程长期得不到CPU时间或锁资源，导致一直无法执行。

可以把线程看成鸟宝宝：

  • CPU是鸟妈妈；

  • 锁资源是食物；

如果某只鸟长期抢不到食物，

就会发生线程饥饿。

四、wait 方法详解

当线程调用：

wait();

会发生两件事：

1. 当前线程进入等待状态

RUNNING
    ↓
WAITING

2. 释放当前持有的锁

这是wait最重要的特性。

例如：

synchronized(lock){
    lock.wait();
}

执行wait后：

释放 lock
进入等待状态

这样其他线程才能获得锁并执行notify。

如果wait不释放锁：

线程A wait

线程B获取不到锁
无法notify

线程A永远等待

程序将陷入死锁状态。

注意事项

wait 和 synchronized 必须使用同一个锁对象

正确：

synchronized(lock){
    lock.wait();
}

错误：

synchronized(lock1){
    lock2.wait();
}

会抛出：

IllegalMonitorStateException

五、单例设计模式

什么是设计模式

设计模式（Design Pattern）：

针对软件开发中的常见问题，总结出来的一套成熟解决方案。

可以理解为程序员的“棋谱”。

什么是单例模式

单例模式要求：

一个类在整个程序运行期间只能创建一个对象。

核心思想：

构造方法私有化
↓
外部无法new
↓
类内部自己创建对象
↓
统一对外提供访问入口

六、饿汉模式

饿汉模式：

类加载时立即创建对象。

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

特点：

  • 实现简单

  • 天然线程安全

  • 获取速度快

缺点：

  • 可能提前创建不需要使用的对象

七、懒汉模式

懒汉模式：

第一次使用时才创建对象。

7.1 普通懒汉模式（线程不安全）

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {

        if(instance == null){
            instance = new Singleton();
        }

        return instance;
    }
}

问题：

多个线程同时进入：

if(instance == null)

可能创建多个对象。

7.2 同步方法

public static synchronized Singleton getInstance(){

    if(instance == null){
        instance = new Singleton();
    }

    return instance;
}

优点：

  • 线程安全

缺点：

  • 每次获取对象都要加锁

  • 性能较低

7.3 双重检查锁（DCL）

public class Singleton {

    private static volatile Singleton instance;

    private Singleton(){}

    public static Singleton getInstance(){

        if(instance == null){

            synchronized(Singleton.class){

                if(instance == null){

                    instance = new Singleton();

                }
            }
        }

        return instance;
    }
}

第一次判断：

if(instance == null)

避免频繁加锁。

第二次判断：

if(instance == null)

防止多个线程重复创建对象。

7.4 为什么需要 volatile

对象创建过程可能发生指令重排序：

1. 分配内存
2. 初始化对象
3. 引用指向对象

可能变成：

1. 分配内存
2. 引用指向对象
3. 初始化对象

此时：

线程A刚执行到步骤2，

线程B发现：

instance != null

直接返回对象。

但对象实际上还没有初始化完成。

因此需要：

private static volatile Singleton instance;

volatile能够禁止这部分重排序，从而保证DCL模式正确运行。

总结

线程安全问题主要来源于：

线程随机调度
        ↓
共享资源竞争
        ↓
原子性问题

内存可见性问题

指令重排序问题

而在单例模式中：

饿汉模式
    ↓
简单、安全

懒汉模式
    ↓
节省资源

DCL + volatile
    ↓
兼顾性能与线程安全
标签
#网络协议 #http
Java多线程——Day03
风间琉璃の博客
07-25 175
多线程Day 03 本文总结自B站狂神说JAVA 1. 线程同步 在Day01中有一个多个线程操作同一个对象的案例，没有处理好并发，所以出现了错误。解决方案：将需要同时访问该对象的线程进入这个对象的等待池形成队列，等前面的线程完毕，下一个线程才可以继续使用，这种方案叫做线程同步。线程同步必须要有队列和锁。说到底线程同步是用来解决线程的安全性问题。缺陷：会损失一部分性能，一个有锁的线程会导致其它需要此锁的线程挂起；一个优先级高的线程如果等待一个优先级低的线程的锁，会导致优先级倒置。 加锁的方法是：在需要同
Linux——多线程—03
最新发布
aaa114514aaaa的博客
05-21 843
有关Linux多线程的学习【模拟实现简单的线程池】【为了保证线程安全的单例模式的学习】【STL和智能指针是否线程安全】【其他常见的锁(主讲自旋锁)】【有关读者写者问题的学习，涉及到读写锁】
C++闲谈03——多线程
yttt的博客
12-01 905
C++闲谈03——多线程
Java复习03 多线程
weixin_47558943的博客
03-15 882
现在，你不想或者不能直接让这个主题去做某件事情，你就创建一个代理，这个代理看起来和主题一样，可以做相同的事情。游戏里你可能会用“跳跃”、“蹲下”、“冲刺”这样的命令来控制你的角色，而在Java编程游戏中，关键字是帮助你控制计算机做事的特殊单词。多线程就好比你在工厂里有很多小机器人一起工作，每个机器人都在做不同的任务，比如一个在装配车轮，一个在画颜色，另一个在打包。这种代理是“静态”的，因为你必须在程序运行之前就决定好谁是代理，谁是主题，就像你在报名表演之前就决定好让你的朋友帮你报名一样。
多线程——03
2301_80055001的博客
12-01 2087
线程的状态，线程安全，volatile关键字
03Java多线程
weixin_43589736的博客
08-23 316
Java多线程 普通方法调用 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OvBzT5GL-1629680825445)(C:\Users\J-ADan\AppData\Roaming\Typora\typora-user-images\image-20210727205324914.png)] 多线程调用 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bIoU7QHU-1629680825448)(C:\Users\J-ADan\AppDa
03_多线程
snailchangquan的博客
09-10 179
#============1、多线程 #python的多线程是伪多线程，通过全局锁控制，各线程切换的很快 import time import threading def big_dog_sleep(wait): print("big_dog_sleep") time.sleep(wait) print("big_dog_aweak") def er_dog_sle...
03多线程常见锁
技术改变世界
10-25 3444
1公平锁、非公平锁 概念：所谓公平锁，就是多个线程按照申请锁的顺序来获取锁，类似排队，先到先得。而非公平锁，则是多个线程抢夺锁，会导致优先级反转或饥饿现象 区别： 公平锁在获取锁时先查看此锁维护的等待队列，为空或者当前线程是等待队列的队列，则直接占有锁，否则插⼊到等待队列，FIFO原则。 非公平锁比较粗鲁，上来直接先尝试占有锁，失败则采⽤公平锁方式。非公平锁的优点是吞吐量比公平锁更大。 synchronized 和 juc.ReentrantLock 默认都是非公平锁。ReentrantLock 在..
Python_03（多线程）
m0_53527658的博客
01-08 138
多线程 优点 使用线程可以把占据长时间的程序中的任务放到后台去处理。 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度 程序的运行速度可能加快 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。 线程和进程 线程在执行过程中与进程还是有区别的。每个独立的进程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用
Java多线程03：多线程深入+多线程综合实例
耿鬼不会笑的博客
03-14 289
Java高级编程03 本文基于 阿里云大学：Java高级编程 整理记录，仅用于个人学习/交流使用。 目录标题Java高级编程03五、多线程深入话题优雅的停止线程后台守护线程volatile关键字六、多线程综合案例数字加减生产电脑竞争抢答 五、多线程深入话题 优雅的停止线程 在多线程操作之中如果要启动多线程肯定使用的是Thread类中的 start()方法，而如果对于多线程需要进行停止处理，Thread类原本提供有 stop()方法，但是对于这些方法从JDK1.2版本开始就已经将其废除了。而且一直到现在也
多线程基础篇-03
qqq932778763的博客
05-08 416
文章目录 ` 第三章 策略模式在多线程中的应用 文章目录文章目录@[TOC](文章目录)一、多线程模拟银行叫号二、用Runnable接口将线程的逻辑执行单元从控制中抽取出来三、策略模式在thread和runnable中的应用分析总结 一、多线程模拟银行叫号 public class TicketWindow extends Thread { private final String name; private static final int MAX = 50; private static int
03多线程的代价
Burgess_Lee的博客
09-05 135
从一个单线程的应用到一个多线程的应用并不仅仅带来好处，它也会有一些代价。不要仅仅为了使用多线程而使用多线程。而应该明确在使用多线程时，能多获取的好处比所付出的代价大的时候，才使用多线程。如果存在疑问，应该尝试测量一下应用程序的性能和响应能力，而不只是猜测。 设计更复杂 虽然有一些多线程应用程序比单线程的应用程序要简单，但其他的一般都更复杂。在多线程访问共享数据的时候，这部分代码需要特别的注意。...
多线程 03 实现方式
qq_41577703的博客
11-29 318
本来要拿离职补偿和失业金，结果公司要加薪续签，哎，反正不忙，要是主动离职我就亏了，那就这样吧，请假面试。2. new 继承类， 调用 start（) 方法， 封装 运行 run() 方法。其实都是 api ， 了解仅此而已 ， 区别， 底层， 没了解，这个视频教我们从第一手资料学习java ，比 直接给代码好，技术增长还是一步一步，做好笔记，适合小镇做题家，哦哦，这个实现方式，之前面试遇到过，也了解过。明白了，这玩意就是使用说明书，，继续看多线程，和 大数据。
Java多线程03
我要，我要，我还要
01-31 169
线程协作——生产者消费者模式 生产者和消费者问题 生产者检查仓库是否已经满了，如果没满，将生产产品；如果仓库已满，停止生产产品。 消费者检查仓库是否已空，仓库不空，消费者消费产品；若空，消费者停止消费产品。 分析： 这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件。 对于生产者,没有生产产品之前,要通知消费者等待。而生产了产品之后,又需要马上通知消...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值