JUC学习（三）：synchronized和Lock实现线程间通信（包含虚假唤醒的讲解）

最新推荐文章于 2023-05-25 11:21:44 发布
最新推荐文章于 2023-05-25 11:21:44 发布
阅读量427 收藏
点赞数
分类专栏： java 文章标签： java juc 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49499183/article/details/123621593
版权

        线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析 ：

        场景---两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信

 

一、synchronized实现 

/**
 * 实现线程A对一个值+1，线程B对该值-1
 */

//第一步：创建资源类，定义属性和操作方法
class Share{
    //目标值
    int number = 0;

    //+1操作
    public synchronized void incr() throws InterruptedException {
        //第二步：判断->操作->通知
        //判断
        if (number != 0){
            this.wait();
        }
        //操作
        number++;
        System.out.println(Thread.currentThread().getName()+":"+number);
        //通知其他线程
        this.notifyAll();
    }

    //-1操作
    public synchronized void decr() throws InterruptedException {
        if (number != 1){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+":"+number);
        this.notifyAll();
    }
}

public class ThreadDemo01 {

    //第二步，创建多个线程，调用资源类中的操作方法
    public static void main(String[] args) {

        Share share = new Share();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程B").start();
    }
}

 

二、虚假唤醒问题 

        现在我们将进程变为四个，A、C进程负责加，B、D进程负责减  

//第一步：创建资源类，定义属性和操作方法
class Share{
    //目标值
    int number = 0;

    //+1操作
    public synchronized void incr() throws InterruptedException {
        //第二步：判断->操作->通知
        //判断
        if (number != 0){
            this.wait();
        }
        //操作
        number++;
        System.out.println(Thread.currentThread().getName()+":"+number);
        //通知其他线程
        this.notifyAll();
    }

    //-1操作
    public synchronized void decr() throws InterruptedException {
        if (number != 1){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+":"+number);
        this.notifyAll();
    }
}

public class ThreadDemo01 {

    //第二步，创建多个线程，调用资源类中的操作方法
    public static void main(String[] args) {

        Share share = new Share();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程D").start();
    }
}

 

                ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​         

        我们可以看到，结果并不是严格的一加一减，而是出现了2、3这样的数字，这是为什么呢？

        这就是要讲的虚假唤醒的问题。

        查阅jdk1.8版本的API，可以看到wait方法中有这样一段话：

         意思是，我们代码中的wait应该放在循环中来避免虚假唤醒，不应该写成：

if (number != 0){
    this.wait();
}

        而应该写成：

while (number != 0){
    this.wait();
}

        为什么会导致这样呢？什么是虚假唤醒呢？

        简而言之，就是wait()方法在唤醒之后，会直接在之前等待的地方继续执行，而不会再执行前面的判断了，这就叫做虚假唤醒。所以要放在循环中，让他唤醒后重新去做判断，避免虚假唤醒的问题。

        所以Share类中正确的代码应是：

class Share{
    //目标值
    int number = 0;

    //+1操作
    public synchronized void incr() throws InterruptedException {
        //第二步：判断->操作->通知
        //判断
        while (number != 0){
            this.wait();
        }
        //操作
        number++;
        System.out.println(Thread.currentThread().getName()+":"+number);
        //通知其他线程
        this.notifyAll();
    }

    //-1操作
    public synchronized void decr() throws InterruptedException {
        while (number != 1){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+":"+number);
        this.notifyAll();
    }
}

        运行结果：

线程A:1
线程B:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程D:0
线程C:1
线程B:0
线程C:1
线程D:0
线程A:1
线程D:0
线程C:1
线程B:0
线程C:1
线程D:0
线程A:1
线程D:0
线程C:1
线程B:0
线程C:1
线程D:0
线程A:1
线程D:0
线程C:1
线程B:0
线程C:1
线程D:0
线程A:1
线程D:0
线程C:1
线程B:0
线程A:1
线程B:0
线程A:1
线程B:0
线程A:1
线程B:0

Process finished with exit code 0

 

 

三、Lock实现四线程操作

/**
 * Lock实现：线程A、C将number值从0变为1，线程B、D将number值从1变为0
 */

class Share{
    private int number = 0;

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1操作
    public void incr() throws InterruptedException {

        lock.lock();

        try{
            while(number != 0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+":"+number);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }

    //-1操作
    public void decr() throws InterruptedException {

        lock.lock();

        try {
            while(number != 1){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+":"+number);
            condition.signalAll();

        } finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo02 {

    public static void main(String[] args) {

        Share share = new Share();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程C").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程D").start();
    }
}

 

        运行结果：

线程A:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程A:1
线程B:0
线程C:1
线程D:0
线程C:1
线程B:0

玉面大蛟龙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程间通信问题
weixin_45417821的博客
07-14 193
文章目录synchronized 方案什么是虚假唤醒？使用while()判断的原因Lock方案 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求用线程间通信 synchronized 方案 package com.sync; //创建资源类，定义属性和操作方法 class Share { //初始值 private int number = 0;
线程池的使用步骤
weixin_49578980的博客
09-17 2730
线程池的使用步骤 使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池 创建一个类,实现Runnable接口,重写run方法,设置线程任务 调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法 调用ExecutorService中的方法shutdown销毁线程池(不建议执行) public class ThreadPool{ public static void main(Str
synchronized 的虚假唤醒
weixin_43861630的博客
01-26 234
问题出现原因 if(num == 0){ //此处会出现【虚假唤醒】 this.wait() } 解决 while(num == 0){ this.wait() } 原因： 拿两个加法线程A、B来说，比如A先执行，执行时调用了wait方法，那它会等待，此时会释放锁，那么线程B获得锁并且也会执行wait方法，两个加线程一起等待被唤醒。此时减线程中的某一个线程执行完毕并且唤醒了这俩加线程，那么这俩加线程不会一起执行，其中A获取了锁并且加1，执行完毕之后B再执行。如果是if的话，那
线程产生的虚假唤醒问题 原因和解决
白鸽
07-21 555
传统模式下的生产者消费者 1、synchronized控制的 class Data{ int number = 0; AtomicInteger atomicInteger = new AtomicInteger(0); public void increment(){ synchronized (this){ // 不等于0进行，等待消费者消费 while (number != 0){
JUC学习之生产者消费者案例-synchronized-虚假唤醒
dyt443733328的博客
04-19 423
本文为看视频学习记录，若有错误请指正！在实际开发过程中，我们可以将添加和创建数据的线程看做是生产者，删除和销毁数据的线程看做是消费者。若不用等待唤醒机制，假设生产者过快，消费者跟不上，那么会导致数据的丢失；                                  假设消费者过快，生产者跟不上，那么可能会导致重复的数据或者是错误的数据；synchronized写法-等待唤醒public c...
JUC多线程学习个人笔记
07-08
Lock接口支持可重入锁，可以精确控制线程的等待和唤醒，而Condition则可以实现线程间的条件等待和通知。 5. **并发工具类**：JUC还包含了一些并发编程的实用工具，如Semaphore（信号量，用于限制同时访问某个资源的...
JUC代码收集，java高并发多线程学习
03-31
- **原子变量**：学习如何使用原子类来实现线程安全的计数器或其他状态变量，避免竞态条件。 - **并发工具类**：掌握`CountDownLatch`, `CyclicBarrier`, `Semaphore`等工具类的应用场景和使用方法。 通过这个"JUC...
【小家java】JUC并发编程之：虚假唤醒以及推荐的解决方案.docx
10-26
【小家java】JUC并发编程之：虚假唤醒以及推荐的解决方案.docx
java8集合源码分析-JUC:高并发与多线程
06-04
Java虚拟机中并没有严格规定synchronized需要如何实现，只要能满足锁住一个对象，一个一个线程的去执行其中的代码块即可。 sync(Object)锁住一个对象，这时会markWord，记录这个线程的ID，这时只有一个线程来，其实...
juc多线程交替打印ABC、熟悉lock的唤醒机制
07-10
现场交替访问、等待和唤醒
java,线程的等待唤醒机制,防止虚假唤醒,用LOCK替代,synchronized,wait,notify,notifyAll方法的实现;
sinat_36572927的博客
02-01 684
     1.先从一个题目说起:两个线程对一个初始值为0的变量擦欧洲哦,实现一个线程加,一个线程-,  以下是这个题目的实现 public class ThreadDemo02 { public static void main(String[] args) { ShareData shareData = new ShareData(); ...
JAVA中使用synchronized关键字实现 生产者和消费者 (虚假唤醒)
一名互联网的吊车尾
12-04 246
前置知识 wait()方法：让当前线程处于等待状态，会释放当前的锁对象。其他线程可以重新拿到锁。 notifyAll()方法：唤醒所有线程。 synchronized ：当前线程拿到锁后，其他现在就无法再去获取锁，会进行监视等待。 这个前置知识必须要先知道，后面也会演示给同学们看 for example: public class Test { public static void main(String[] args) { Test2 test2 = new Test2();
Java线程虚假唤醒
weixin_49050715的博客
07-13 319
文章目录什么是虚假唤醒为什么会出现虚假唤醒解决的方法 #什么是虚假唤醒 #为什么会出现虚假唤醒 #解决的方法 什么是虚假唤醒 如图，JavaJdk10API文档这样描述 意思就是说线程可以在没有被通知，中断或者超时的情况下被唤醒，这就是所谓的虚假唤醒 为什么会出现虚假唤醒 1.当Object.wait()这个方法运行时，当前的线程会进入等待状态，并自动释放锁。当被其他线程唤醒时，它会在wait()之后的地方继续开始运行 2.当Object.notifyAll运行时，会唤醒所有处于等待状态的线程同时进行抢
JUC 高并发编程(2)：同步案例：synchronized，生产者与消费者，多线程的虚假唤醒
Mr_tianyanxiaobai的博客
08-06 208
synchronize 案例 以售票问题为例，假设这里存在三个线程用来买票，则代码如下： public class SellTicket implements Runnable { //定义一个成员变量表示有100张票 private int tickets=100; public void run(){ while (true){ if(tickets>0){ try { //通过slee
JUC编程——（一）（线程的状态，sleep和wait的区别，Lock锁，synchronized和Lock的区别，虚假唤醒，Lock版生产者消费者问题，Condition实现精准通知唤醒）
weixin_44324174的博客
04-09 400
1、什么是JUC？ JUC就是java.util.concurrent。 2、进程和线程 进程：一个应用程序，双击qq就是qq进程启动。 线程：一个进程中包含多个线程，qq中有多个任务，你同事可以和多个人聊天，这每个任务就是一个线程。 Java默认有一个线程？ 两个，main线程和GC线程。 Java真的可以开启线程吗？ 不能，我们可以看一下源码: //同步方法块 很安全 public sync...
生产者和消费者问题 Synchronized 版本，防止虚假唤醒
qq_42732184的博客
05-03 303
package com.han.demo01; public class TestPC { public static void main(String[] args) { Data data = new Data(); new Thread(() -> { for (int i = 0; i < 20; i++) { try { data.increment
synchronized实现生产者消费者通信问题及可能产生的虚假唤醒问题
微滑低的博客
06-14 101
文章目录1.解决生产者消费者问题三步骤2.代码（测试类、资源类）3.虚假唤醒问题5.原因分析6.问题解决 学习地址：狂神Bilibili个人主页 1.解决生产者消费者问题三步骤 等待唤醒 业务 通知唤醒 2.代码（测试类、资源类） /** * 线程交替执行 A B 操作同一个变量 num = 0 * A num+1 * B num-1 */ public class A { public static void main(String[] args) { Da
JUC中Synchronized和Lock区别
2301_77899321的博客
05-25 122
JUC中Synchronized和Lock区别
JUC代码演示 Java多线程并发
最新发布
05-03
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值