五、线程间通信

已于 2022-07-01 22:16:11 修改
阅读量68 收藏
点赞数
分类专栏： 2023最详细JAVA并发编程JUC教程 文章标签： java 开发语言 后端
于 2021-11-15 23:02:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42841433/article/details/121345808
版权

五、线程间通信

文章目录

1、面试题：两个线程打印

两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B…5152Z

1、synchronized实现
package com.xue.thread;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
 
 
class ShareDataOne//资源类
{
  private int number = 0;//初始值为零的一个变量
 
  public synchronized void increment() throws InterruptedException 
  {
     //1判断
     if(number !=0 ) {
       this.wait();
     }
     //2干活
     ++number;
     System.out.println(Thread.currentThread().getName()+"\t"+number);
     //3通知
     this.notifyAll();
  }
  
  public synchronized void decrement() throws InterruptedException 
  {
     // 1判断
     if (number == 0) {
       this.wait();
     }
     // 2干活
     --number;
     System.out.println(Thread.currentThread().getName() + "\t" + number);
     // 3通知
     this.notifyAll();
  }
}
 
/**
 * 
 * @Description:
 *现在两个线程，
 * 可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 交替，来10轮。 
 * @author xialei
 *
 *  * 笔记：Java里面如何进行工程级别的多线程编写
 * 1 多线程变成模板（套路）-----上
 *     1.1  线程    操作    资源类  
 *     1.2  高内聚  低耦合
 * 2 多线程变成模板（套路）-----下
 *     2.1  判断
 *     2.2  干活
 *     2.3  通知
 
 */
public class NotifyWaitDemoOne
{
  public static void main(String[] args)
  {
     ShareDataOne sd = new ShareDataOne();
     new Thread(() -> {
       for (int i = 1; i < 10; i++) {
          try {
            sd.increment();
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
       }
     }, "A").start();
     new Thread(() -> {
       for (int i = 1; i < 10; i++) {
          try {
            sd.decrement();
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
       }
     }, "B").start();
  }
}
/*
 * * 
 * 2 多线程变成模板（套路）-----下
 *     2.1  判断
 *     2.2  干活
 *     2.3  通知
 * 3 防止虚假唤醒用while
 * 
 * 
 * */
2、换成4个线程

​ 换成4个线程会导致错误，虚假唤醒

​ 原因：在java多线程判断时，不能用if，程序出事出在了判断上面，

突然有一添加的线程进到if了，突然中断了交出控制权，

没有进行验证，而是直接走下去了，加了两次，甚至多次

3、4个线程解决方案

解决虚假唤醒：查看API，java.lang.Object
在这里插入图片描述

中断和虚假唤醒是可能产生的，所以要用loop循环，if只判断一次，while是只要唤醒就要拉回来再判断一次。if换成while

4、java8新版实现

在这里插入图片描述

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 
 
   final Object[] items = new Object[100];
   int putptr, takeptr, count;
 
   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

package com.xue.thread;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
import org.omg.IOP.Codec;
 
 
class ShareData//资源类
{
  private int number = 0;//初始值为零的一个变量
 
  private Lock lock = new ReentrantLock();
  private Condition condition  = lock.newCondition(); 
   
  public  void increment() throws InterruptedException 
  {
     
      lock.lock();
         try {
          //判断
          while(number!=0) {
            condition.await();
          }
          //干活
          ++number;
          System.out.println(Thread.currentThread().getName()+" \t "+number);
          //通知
          condition.signalAll();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
     
  }
  
  
  public  void decrement() throws InterruptedException 
  {
      
      lock.lock();
         try {
          //判断
          while(number!=1) {
            condition.await();
          }
          //干活
          --number;
          System.out.println(Thread.currentThread().getName()+" \t "+number);
          //通知
          condition.signalAll();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
     
  }
  
  /*public synchronized void increment() throws InterruptedException 
  {
     //判断
     while(number!=0) {
       this.wait();
     }
     //干活
     ++number;
     System.out.println(Thread.currentThread().getName()+" \t "+number);
     //通知
     this.notifyAll();;
  }
  
  public synchronized void decrement() throws InterruptedException 
  {
     //判断
     while(number!=1) {
       this.wait();
     }
     //干活
     --number;
     System.out.println(Thread.currentThread().getName()+" \t "+number);
     //通知
     this.notifyAll();
  }*/
}
 
/**
 * 
 * @Description:
 *现在两个线程，
 * 可以操作初始值为零的一个变量，
 * 实现一个线程对该变量加1，一个线程对该变量减1，
 * 交替，来10轮。 
 *
 *  * 笔记：Java里面如何进行工程级别的多线程编写
 * 1 多线程变成模板（套路）-----上
 *     1.1  线程    操作    资源类  
 *     1.2  高内聚  低耦合
 * 2 多线程变成模板（套路）-----下
 *     2.1  判断
 *     2.2  干活
 *     2.3  通知
 
 */
public class NotifyWaitDemo
{
  public static void main(String[] args)
  {
     ShareData sd = new ShareData();
     new Thread(() -> {
 
       for (int i = 1; i <= 10; i++) {
          try {
            sd.increment();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
       }
     }, "A").start();
     
     new Thread(() -> {
 
       for (int i = 1; i <= 10; i++) {
          try {
            sd.decrement();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
       }
     }, "B").start();
     new Thread(() -> {
 
       for (int i = 1; i <= 10; i++) {
          try {
            sd.increment();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
       }
     }, "C").start();
     new Thread(() -> {
 
       for (int i = 1; i <= 10; i++) {
          try {
            sd.decrement();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
       }
     }, "D").start();
     
  }
}

/*
 * * 
 * 2 多线程变成模板（套路）-----下
 *     2.1  判断
 *     2.2  干活
 *     2.3  通知
 * 3 防止虚假唤醒用while
 * 
 * 
 * */

2、线程间定制化调用通信

1、有顺序通知，需要有标识位

2、有一个锁Lock，3把钥匙Condition

3、判断标志位

4、输出线程名+第几次+第几轮

5、修改标志位，通知下一个

package com.xue.thread;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
 
class ShareResource
{
  private int number = 1;//1:A 2:B 3:C 
  private Lock lock = new ReentrantLock();
  private Condition c1 = lock.newCondition();
  private Condition c2 = lock.newCondition();
  private Condition c3 = lock.newCondition();
 
  public void print5(int totalLoopNumber)
  {
     lock.lock();
     try 
     {
       //1 判断
       while(number != 1)
       {
          //A 就要停止
          c1.await();
       }
       //2 干活
       for (int i = 1; i <=5; i++) 
       {
          System.out.println(Thread.currentThread().getName()+"\t"+i+"\t totalLoopNumber: "+totalLoopNumber);
       }
       //3 通知
       number = 2;
       c2.signal();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
  }
  public void print10(int totalLoopNumber)
  {
     lock.lock();
     try 
     {
       //1 判断
       while(number != 2)
       {
          //A 就要停止
          c2.await();
       }
       //2 干活
       for (int i = 1; i <=10; i++) 
       {
          System.out.println(Thread.currentThread().getName()+"\t"+i+"\t totalLoopNumber: "+totalLoopNumber);
       }
       //3 通知
       number = 3;
       c3.signal();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
  }  
  
  public void print15(int totalLoopNumber)
  {
     lock.lock();
     try 
     {
       //1 判断
       while(number != 3)
       {
          //A 就要停止
          c3.await();
       }
       //2 干活
       for (int i = 1; i <=15; i++) 
       {
          System.out.println(Thread.currentThread().getName()+"\t"+i+"\t totalLoopNumber: "+totalLoopNumber);
       }
       //3 通知
       number = 1;
       c1.signal();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       lock.unlock();
     }
  }  
}
 
 
/**
 * 
 * @Description: 
 * 多线程之间按顺序调用，实现A->B->C
 * 三个线程启动，要求如下：
 * 
 * AA打印5次，BB打印10次，CC打印15次
 * 接着
 * AA打印5次，BB打印10次，CC打印15次
 * ......来10轮  
 *
 */
public class ThreadOrderAccess
{
  public static void main(String[] args)
  {
     ShareResource sr = new ShareResource();
     
     new Thread(() -> {
       for (int i = 1; i <=10; i++) 
       {
          sr.print5(i);
       }
     }, "AA").start();
     new Thread(() -> {
       for (int i = 1; i <=10; i++) 
       {
          sr.print10(i);
       }
     }, "BB").start();
     new Thread(() -> {
       for (int i = 1; i <=10; i++) 
       {
          sr.print15(i);
       }
     }, "CC").start();   
  }
}

下一篇：LockSupport与线程中断

更多内容：

更多内容大家可以关注一下个人博客网，https://blog.xueqimiao.com/,内容更丰富喔。
在这里插入图片描述
回复JUC可以获取完整md文档喔，谢谢关注。

小薛博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多线程——精确通知顺序访问
weixin_48149536的博客
05-31 183
package com.dym.jvm; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class ShareResource { private int number = 1;//1:A 2:B 3:C private Lock lock = new Re...
android 线程间通信
05-28
### Android线程间通信详解 #### 一、引言 Android应用程序通常运行在单个主线程上，称为“主线程”或“UI线程”。为了提高应用性能和用户体验，开发者经常需要利用多线程技术来执行后台任务，比如下载图片、获取...
JUC-线程间通信
weixin_30922589的博客
08-26 131
面试题： 两个线程，一个线程打印1-52，另一个打印字母A-Z打印顺序为12A34B...5152Z, 要求用线程间通信 线程间通信：1、生产者+消费者2、通知等待唤醒机制 多线程编程模版中 1、判断 2、干活 3、唤醒 synchronized实现 package com.atguigu.thread; import java.util.concu...
Qt 线程与线程之间数据传递
比卡丘不皮的博客
11-11 6336
有时候我们需要不同的线程之间进行数据的传送，使得数据合并，达到完成的数据，这里简单记录下线程之间的传递。基本思想通过槽函数也让线程1与线程2绑定发送数据与接受数据函数。 创建一个QT Widgets工程，添加两个线程类。OneThread，与 twoThread onethread.h #ifndef ONETHREAD_H #define ONETHREAD_H #include <QObject> #include <QThread> class OneThread.
进程间通信&线程间通信
渣渣
07-26 2266
一、多进程： 首先，先来讲一下fork之后，发生了什么事情。 由fork创建的新进程被称为子进程（child process）。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进程 id。将子进程id返回给父进程的理由是：因为一个进程的子进程可以多于一个，没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说，之所以fork返回0给它，是因为它随时可以调用getpid()来获取自己的pid；也可以调用getppid()来获取父进程的id
线程间通信
weixin_53812805的博客
05-02 4122
目录 一、线程理论基础 1、什么是线程 2、为什么有了进程，还要引入线程呢？ （使用多线程到底有哪些好处？） 3、线程的缺点 二、多线程间通信 1、多线程通信的注意事项 2、创建线程的步骤 3、终止线程的方式 4、线程 API 使用 （1）pthread_create() 函数 （创建线程） （2）pthread_exit()函数 （结束线程） （3）pthread_join()函数 （等待线程结束） 三、线程同步 1、互斥量 （1）互斥量注意事项 （2）互斥锁创建步..
Python中线程间通信
精益求精，永无止境，永远在路上！
07-29 6235
快来和我一起学习Python中线程间通信（一起努力，咱们顶峰相见！！！）
【Android】线程间通信——Handler消息机制
qq_40265247的博客
04-10 1563
优先级队列，按时间 enqueueMessage()中msg.target = this; 导致msg持有handler，而handler持有activity（内部类持有外部类的对象），而msg又在外部类的生命周期内。导致内存泄漏 保证looper线程唯一：ThreadLocal static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); final MessageQueue mQ
线程间通信的常用方式
zh123456_789的博客
02-17 1371
线程间通信的常用方式
线程间通信的几种实现方式
热门推荐
InterfaceJ的博客
01-13 18万+
线程间通信的几种实现方式 首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目：有两个线程A、B，A线程向一个集合里面依次添加元素&amp;quot;abc&amp;quot;字符串，一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。 方式一：使用 volatile 关键字 基于 volatile...
OpenHarmony的线程间通信EventHandler
流风的专栏
04-20 6505
​ EventHandler是一种用户在当前线程上投递InnerEvent事件或者Runnable任务到异步线程上处理的机制。每一个EventHandler和指定的EventRunner所创建的线程绑定，并且该线程内部有一个事件队列。​ EeventHandler可以投递指定的InnerEvent事件或Runnable任务到这个队列。EventRunner从事件队列里循环地取出事件，如果取出的事件是InnerEvent事件，将在EventRunner所在线程执行ProcessEvent回调。
Java线程间通信的代码示例.zip
08-15
Java线程间通信是多线程编程中的一个重要概念，它涉及到如何在并发执行的线程之间有效地传递信息和协调工作。在Java中，线程间通信主要通过共享内存（如共享变量）和消息传递（如wait(), notify(), notifyAll()等...
android_线程间的通信 详细
09-14
### Android线程间通信详解 #### 一、引言 Android应用开发中，线程间的通信是一项非常重要的技术。为了确保应用的响应性和流畅性，通常会将一些耗时的操作（比如网络请求、数据库访问等）放到后台线程中执行，而...
Android中线程间通信.pdf
07-25
#### 五、线程间通信的方法 Android提供了多种方式进行线程间通信，包括但不限于： 1. **Handler机制**： - **基本原理**：Handler机制是基于消息队列的方式实现的。Handler对象可以发送消息到消息队列，Looper则...
基于MFC开发的多线程串口通信上位机
08-11
3. **线程通信**: 可以使用消息队列或者事件对象（如CEvent）来实现线程间的通信和协作。 **四、MFCAPI串口实现** 结合MFC和API，我们可以创建一个名为MFCAPI_SerialComm的类，这个类封装了串口的打开、关闭、读写...
【Spring Boot】高效配置管理: 易用性与灵活性并重
最新发布
weixin_68020300的博客
08-07 882
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 428
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
jiaowenjie的专栏
08-06 187
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1261
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
Linux进程间通信（IPC）教程：管道与套接口解析
"这篇教程主要介绍了Linux进程间通信IPC的各种方式，包括管道、命名管道、消息队列、信号量、共享空间和套接口。其中，前五种IPC主要用于同一主机内的进程通信，而套接口可以支持跨主机的通信。在讲解中，文章特别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小薛博客

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

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

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

打赏作者

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

抵扣说明：

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

余额充值