Java学习 --- JUC线程通信

已于 2022-08-31 06:36:24 修改
阅读量470 收藏
点赞数
分类专栏： JUC 文章标签： java
于 2022-03-22 19:44:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46093575/article/details/123668836
版权

目录

一、线程通信使用synchronized实现

 二、基于lock接口实现

一、线程通信使用synchronized实现

案例：使用两个线程，实现对一个初始值是0的变量操作，一个线程对其进行加一操作，另一个线程对其进行减一操作，这个过程就是线程通信。

三步骤：判断、干活、通知

参考示例代码：

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();
                }
            }
        },"aa").start();
        //创建线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"bb").start();
    }
}
/**
 * 创建资源类
 */
class Share{
    private int number = 0;
    //加的方法
    public synchronized void  incr() throws InterruptedException {
        //判断number是否为零,不是零就等待
        if (number != 0){
            this.wait();
        }
        //不为零就加一
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他线程
        this.notifyAll();
    }
    //减的方法
    public synchronized void  decr() throws InterruptedException {
       //判断number是否为一,不是一就等待
        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();
                }
            }
        },"aa").start();
        //创建线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"bb").start();
        //创建线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"cc").start();
        //创建线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"dd").start();
    }
}
/**
 * 创建资源类
 */
class Share{
    private int number = 0;
    //加的方法
    public synchronized void  incr() throws InterruptedException {
        //判断number是否为零,不是零就等待
        if (number != 0){
            this.wait();
        }
        //不为零就加一
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他线程
        this.notifyAll();
    }
    //减的方法
    public synchronized void  decr() throws InterruptedException {
        //判断number是否为一,不是一就等待
        if (number != 1){
            this.wait();
        }
        //不为零就加一
        number--;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他线程
        this.notifyAll();
    }
}

运行结果：

 

原因是wait方法引起的：

 由于wait方法的特点就是在那里睡就在那里醒，会导致if判断条件失效。

解决方法将if判断修改为while循环

参考示例代码：

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();
                }
            }
        },"aa").start();
        //创建线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"bb").start();
        //创建线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"cc").start();
        //创建线程
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"dd").start();
    }
}
/**
 * 创建资源类
 */
class Share{
    private int number = 0;
    //加的方法
    public synchronized void  incr() throws InterruptedException {
        //判断number是否为零,不是零就等待
        while (number != 0){
            this.wait();
        }
        //不为零就加一
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他线程
        this.notifyAll();
    }
    //减的方法
    public synchronized void  decr() throws InterruptedException {
       //判断number是否为一,不是一就等待
        while (number != 1){
            this.wait();
        }
        //不为零就加一
        number--;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        //通知其他线程
        this.notifyAll();
    }
}

正确运行结果：

 

 二、基于lock接口实现

public class ThreadDemo2 {
    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();
                }
            }
        },"aa").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"bb").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"cc").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"dd").start();
    }
}
class Share{
    private int number = 0;
    //创建lock对象
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    //加
    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();
        }
    }
    //减
    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();
        }
    }
}

java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
05-Java多线程并发编程JUC.pdf
09-16
3. 线程通信 线程间通信主要通过以下几种方法实现： - wait()：使当前执行的线程进入等待状态，并释放对象锁。 - notify()：唤醒在此对象监视器上等待的单个线程。 - notifyAll()：唤醒在此对象监视器上等待的...
JUC之线程通信
weixin_38568503的博客
03-04 501
Java多线程的wait()方法和notify()方法 这两个方法是成对出现和使用的，要执行这两个方法，有一个前提就是，当前线程必须获其对象的monitor（俗称“锁”），否则会抛出IllegalMonitorStateException异常，所以这两个方法必须在同步块代码里面调用。 wait()：阻塞当前线程 notify()：唤起被wait()阻塞的线程 ...
JUC - 线程通信：
上山打卤面的博客
03-08 214
线程通信： 面试题：两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B…5152Z 上面的问题方式有非常多种 但是万变不离其宗 就是多线程顺序输出 我们都知道 多线程的启动不是按照start方法在代码中的先后顺序进行执行的 线程启动的顺序是不确定的 多线程编程就是要将不确定的 变为确定 （这也是多线程的魅力）这必然需要一套线程之间的通信机制 – 也就是通知等待唤醒机...
JUC笔记(三) --- 线程的通信
qq_57115378的博客
10-27 336
Java线程间的通信
java线程间通讯的几种方式
成都彭于晏
02-04 6067
并发编程中，我们可能会遇到这样一个场景 A、B两个线程并行，但是我希望保证B线程在A线程执行完了后再执行 这个时候就需要线程间进行通讯 A执行完了后对B说一声，喂B，我执行完了 来康康用Java怎么实现 1、基于synchronized 2、基于reentrantLock 3、基于volatile 4、基于countDownLatch 我目前就知道这四种 1、synchronized+wait() 和 notify() wait() 和 notify()都是Object类的通讯方法，注意一点，wai
JUC并发编程基础（5）--Java线程间的通信
qq_42194397的博客
05-25 153
Java线程间的通信
JAVA线程高级-线程按序交替执行
11-01
在Java编程中，多线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而提高了系统的效率和响应性。然而，在某些场景下，我们可能需要控制线程的执行顺序，确保它们按照特定的顺序交替运行，这在并发编程...
Java 多线程与并发(16-26)-JUC集合- BlockingQueue详解.pdf
最新发布
07-27
Java中的`BlockingQueue`接口是Java并发编程的重要组件，它位于`java.util.concurrent`包下，主要用于线程间数据的同步和通信。`BlockingQueue`是一个支持线程安全的队列，它允许一个线程放入（插入）元素，而另一个...
个人学习-JUC-笔记
02-25
Java并发编程是Java开发中的重要领域，而JUC（Java Util Concurrency）是Java平台提供的一套高级并发工具包，它极大地简化了多线程和并发控制的复杂性。本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人...
JUC-线程间通信
Logan的博客
08-23 156
3 线程间通信 线程间通信的模型有两种：共享内存和消息传递，以下方式都是基于这两种模 型来实现的。 场景—两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求 用线程间通信 3.1 synchronized 方案 /** * volatile 关键字实现线程交替加减 */ public class TestVolatile { /** * 交替加减 * * @param args */ public static void ma
JUC- 线程间通信
che_j的博客
10-20 214
两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1
JUC之线程间通信
Y_Ace的博客
04-15 153
前言 我们知道了什么是线程, 知道了什么是锁, 但是怎样编写多线程程序呢? 通过下面的文章将告诉大家编写一个简单的多线程程序需要那几步。 线程间通信 谈到线程间通信就不得不说一个经典的生产者-消费者模型, 我们假定这样一个场景: 一个小小的饮品店, 桌子太小了每次只能放一杯饮品 桌子上没有饮品的时候顾客就会等待 桌子上有饮品的时候店长就不做了(很佛系) 我们尝试用代码实现以下这个场景: 把饮品店, 饮品, 做饮品, 取饮品给抽象出来 class IceCream{ //饮品 priv
JUC | JUC线程间的通信
蕤荥的成长博客
11-09 263
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
JUC之线程间的通信
wdjnb的博客
12-30 419
线程通信 创建资源类，在资源类中创建属性和操作方法 在资源类里面操作 判断 干活 通知 创建多个线程，调用资源类的操作方法 线程通信的实现例子： 两个线程，实现对一个初始变量为0进行操作，一个线程对其+1，一个线程对其-1，使得变量结果不改变 使用Synchronized实现的线程通信： package com.JUC; /** * 创建资源类 */ class Share{ //初始值 private int number = 0; //创.
JUC如是实现线程之间的通信
weixin_42022924的博客
10-29 370
1. Condition 组件 在jdk中，synchronized可以实现线程通信，wait/notify 方法；在Condition中提供了多线程协调的通信，可以让某一个线程等待，只有条件满足才能被唤醒； 1.1 Condition使用 ...
JUC学习（二）- 线程间的通信
weixin_45716265的博客
10-20 149
一、线程间的通信 （一）多线程交互的虚假唤醒 （1）虚假唤醒重现 //资源类 class AirConditioner{ private int number = 0; public synchronized void increment() throws InterruptedException { //1判断 if(number != 0) { this.wait(); } //2干活
JUC学习笔记（2）—线程间通信
java_kider的博客
07-31 229
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class ShareData { private int number = 0; private Lock lock = ...
JUC高并发编程(03) -- 线程间通信
姜皓的博客
05-08 279
线程间通信
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鸭鸭老板

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值