每天一例多线程[day9]-----多线程间的通信

最新推荐文章于 2024-06-17 14:19:02 发布
最新推荐文章于 2024-06-17 14:19:02 发布
阅读量92 收藏
点赞数
分类专栏： 多线程

volatile实现

 

  1. package com.jeff.base.conn008;

  2.  

  3. import java.util.ArrayList;

  4. import java.util.List;

  5. /**

  6. * 定义t1和t2两个线程：

  7. * t1线程往list中加入元素

  8. * t2线程发现list元素个数为5时抛出异常，停止t2线程

  9. *

  10. * @author jeff

  11. * @param args

  12. */

  13. public class ListAdd1 {

  14.  

  15. private volatile static List list = new ArrayList();

  16.  

  17. public void add(){

  18. list.add("bjsxt");

  19. }

  20. public int size(){

  21. return list.size();

  22. }

  23.  

  24. public static void main(String[] args) {

  25.  

  26. final ListAdd1 list1 = new ListAdd1();

  27.  

  28. Thread t1 = new Thread(new Runnable() {

  29. @Override

  30. public void run() {

  31. try {

  32. for(int i = 0; i <10; i++){

  33. list1.add();

  34. System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");

  35. Thread.sleep(500);

  36. }

  37. } catch (InterruptedException e) {

  38. e.printStackTrace();

  39. }

  40. }

  41. }, "t1");

  42.  

  43. Thread t2 = new Thread(new Runnable() {

  44. @Override

  45. public void run() {

  46. while(true){

  47. if(list1.size() == 5){

  48. System.out.println("当前线程收到通知："

  49. + Thread.currentThread().getName() + " list size = 5 线程停止..");

  50. throw new RuntimeException();

  51. }

  52. }

  53. }

  54. }, "t2");

  55.  

  56. t1.start();

  57. t2.start();

  58. }

  59.  
  60.  

  61. }

打印结果：

 

  1. 当前线程：t1添加了一个元素..

  2. 当前线程：t1添加了一个元素..

  3. 当前线程：t1添加了一个元素..

  4. 当前线程：t1添加了一个元素..

  5. 当前线程：t1添加了一个元素..

  6. 当前线程收到通知：t2 list size = 5 线程停止..

  7. Exception in thread "t2" java.lang.RuntimeException

  8. at com.jeff.base.conn008.ListAdd1$2.run(ListAdd1.java:50)

  9. at java.lang.Thread.run(Thread.java:722)

  10. 当前线程：t1添加了一个元素..

  11. 当前线程：t1添加了一个元素..

  12. 当前线程：t1添加了一个元素..

  13. 当前线程：t1添加了一个元素..

  14. 当前线程：t1添加了一个元素..

 

wait和notify实现

 

  1. package com.jeff.base.conn008;

  2.  

  3. import java.util.ArrayList;

  4. import java.util.List;

  5. import java.util.Queue;

  6. import java.util.concurrent.CountDownLatch;

  7. import java.util.concurrent.LinkedBlockingDeque;

  8. import java.util.concurrent.LinkedBlockingQueue;

  9. /**

  10. * wait notfiy 方法，wait释放锁，notfiy不释放锁

  11. * @author jeff

  12. *

  13. */

  14. public class ListAdd2 {

  15. private volatile static List list = new ArrayList();

  16.  

  17. public void add(){

  18. list.add("bjsxt");

  19. }

  20. public int size(){

  21. return list.size();

  22. }

  23.  

  24. public static void main(String[] args) {

  25.  

  26. final ListAdd2 list2 = new ListAdd2();

  27.  

  28. // 1 实例化出来一个 lock

  29. // 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用

  30. final Object lock = new Object();

  31.  
  32.  

  33. // final CountDownLatch countDownLatch = new CountDownLatch(1);

  34.  

  35. Thread t1 = new Thread(new Runnable() {

  36. @Override

  37. public void run() {

  38. try {

  39. synchronized (lock) {

  40. for(int i = 0; i <10; i++){

  41. list2.add();

  42. System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");

  43. Thread.sleep(500);

  44. if(list2.size() == 5){

  45. System.out.println("已经发出通知..");

  46. // countDownLatch.countDown();

  47. lock.notify();

  48. }

  49. }

  50. }

  51. } catch (InterruptedException e) {

  52. e.printStackTrace();

  53. }

  54.  

  55. }

  56. }, "t1");

  57.  

  58. Thread t2 = new Thread(new Runnable() {

  59. @Override

  60. public void run() {

  61. synchronized (lock) {

  62. if(list2.size() != 5){

  63. try {

  64. System.out.println("t2进入...");

  65. lock.wait();

  66. // countDownLatch.await();

  67. } catch (InterruptedException e) {

  68. e.printStackTrace();

  69. }

  70. }

  71. System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");

  72. throw new RuntimeException();

  73. }

  74. }

  75. }, "t2");

  76.  

  77. t2.start();

  78. t1.start();

  79.  

  80. }

  81.  

  82. }

打印结果：

 

  1. t2进入...

  2. 当前线程：t1添加了一个元素..

  3. 当前线程：t1添加了一个元素..

  4. 当前线程：t1添加了一个元素..

  5. 当前线程：t1添加了一个元素..

  6. 当前线程：t1添加了一个元素..

  7. 已经发出通知..

  8. 当前线程：t1添加了一个元素..

  9. 当前线程：t1添加了一个元素..

  10. 当前线程：t1添加了一个元素..

  11. 当前线程：t1添加了一个元素..

  12. 当前线程：t1添加了一个元素..

  13. 当前线程：t2收到通知线程停止..

  14. Exception in thread "t2" java.lang.RuntimeException

  15. at com.jeff.base.conn008.ListAdd2$2.run(ListAdd2.java:72)

  16. at java.lang.Thread.run(Thread.java:722)

我们发现以后结果并不是实时的，分析下执行过程：

     t2线程先执行，执行到await方法时释放锁，然后t1获得锁，当t1添加5个元素后，调用notify方法唤醒t2线程，但是notify方法并不释放锁，所以t2线程此时并不能得到锁，直到t1线程添加完10个元素以后释放锁，t2线程await才不再阻塞，打印“收到通知线程停止”。

 

CountDownLatch方式

 

  1. package com.jeff.base.conn008;

  2.  

  3. import java.util.ArrayList;

  4. import java.util.List;

  5. import java.util.Queue;

  6. import java.util.concurrent.CountDownLatch;

  7. import java.util.concurrent.LinkedBlockingDeque;

  8. import java.util.concurrent.LinkedBlockingQueue;

  9. /**

  10. * wait notfiy 方法，wait释放锁，notfiy不释放锁

  11. * @author jeff

  12. *

  13. */

  14. public class ListAdd2 {

  15. private volatile static List list = new ArrayList();

  16.  

  17. public void add(){

  18. list.add("bjsxt");

  19. }

  20. public int size(){

  21. return list.size();

  22. }

  23.  

  24. public static void main(String[] args) {

  25.  

  26. final ListAdd2 list2 = new ListAdd2();

  27.  

  28. // 1 实例化出来一个 lock

  29. // 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用

  30. // final Object lock = new Object();

  31.  
  32.  

  33. final CountDownLatch countDownLatch = new CountDownLatch(1);

  34.  

  35. Thread t1 = new Thread(new Runnable() {

  36. @Override

  37. public void run() {

  38. try {

  39. // synchronized (lock) {

  40. for(int i = 0; i <10; i++){

  41. list2.add();

  42. System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");

  43. Thread.sleep(500);

  44. if(list2.size() == 5){

  45. System.out.println("已经发出通知..");

  46. countDownLatch.countDown();

  47. // lock.notify();

  48. }

  49. }

  50. // }

  51. } catch (InterruptedException e) {

  52. e.printStackTrace();

  53. }

  54.  

  55. }

  56. }, "t1");

  57.  

  58. Thread t2 = new Thread(new Runnable() {

  59. @Override

  60. public void run() {

  61. // synchronized (lock) {

  62. if(list2.size() != 5){

  63. try {

  64. System.out.println("t2进入...");

  65. // lock.wait();

  66. countDownLatch.await();

  67. } catch (InterruptedException e) {

  68. e.printStackTrace();

  69. }

  70. }

  71. System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");

  72. throw new RuntimeException();

  73. // }

  74. }

  75. }, "t2");

  76.  

  77. t2.start();

  78. t1.start();

  79.  

  80. }

  81.  

  82. }

打印结果：

 

  1. t2进入...

  2. 当前线程：t1添加了一个元素..

  3. 当前线程：t1添加了一个元素..

  4. 当前线程：t1添加了一个元素..

  5. 当前线程：t1添加了一个元素..

  6. 当前线程：t1添加了一个元素..

  7. 已经发出通知..

  8. Exception in thread "t2" java.lang.RuntimeException

  9. at com.jeff.base.conn008.ListAdd2$2.run(ListAdd2.java:72)

  10. at java.lang.Thread.run(Thread.java:722)

  11. 当前线程：t1添加了一个元素..

  12. 当前线程：t2收到通知线程停止..

  13. 当前线程：t1添加了一个元素..

  14. 当前线程：t1添加了一个元素..

  15. 当前线程：t1添加了一个元素..

  16. 当前线程：t1添加了一个元素..

执行countDown方法后，计数器减去1，变为0，t2线程停止阻塞实时开始执行...

qq_36014627
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day07【线程池、Lambda表达式】-笔记.pdf
08-16
总结来看，理解线程通信概念和等待唤醒机制对于开发多线程程序至关重要，线程池的使用能有效提升程序的性能和资源利用率，而Lambda表达式的引入则简化了函数式编程的实现。这些知识点对于Java开发者来说是必须掌握的...
初学者必看多线程倒计时器
08-11
本文介绍了如何使用Java Swing GUI框架、多线程以及日期时间处理技术来实现一个简单的多线程倒计时器。通过这个例子，读者可以了解到如何在Java中构建GUI应用程序，如何利用多线程来实现后台任务的并发执行，以及...
每天一例多线程[day8]-----AutomicInteger原子操作
抱愚守拙，持之以恒；不问结果，相信过程.
06-03 6187
即使我们使用volitile，也无法保证多线程访问共享变量的原子性，如下：package com.jeff.base.sync007; /** * * volatile关键字不具备synchronized关键字的原子性（同步） * @author jeff * */ public class VolatileNoAtomic extends Thread{ private stati...
多线程学习Day05-加餐
weixin_45906118的博客
04-28 1042
这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一 条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了 指令地吞吐率。happens-before 规定了对共享变量的写操作对其它线程的读操作可见，它是可见性与有序性的一套规则总结，抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见。枚举实例的创建是由Java虚拟机在类加载时处理的，这个过程是线程安全的。
JavaSE-多线程（11）- LockSupport
sql2008help的博客
11-21 507
JavaSE-多线程（11）- LockSupport 使用LockSupport 类可使线程暂停，请看下例： 例1 线程 t1 执行 LockSupportTest 类run方法，在run方法中，每隔1秒输出一次 i 的值，一共输出10次，在i等于5时暂停线程，主线程睡眠8秒后，调用 activate 方法（实际调用 LockSupportTest 对象即锁的notify方法），t1线程继续执行 package com.hs.example.base.multithread.day01; public
每天一例多线程[day1]-----synchronized与锁竞争
抱愚守拙，持之以恒；不问结果，相信过程.
06-03 759
/**  * 多个线程一把锁  *   * 线程安全概念：  *     当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为，  * 那么这个类（对象或方法）就是线程安全的。  *   * synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区"  *   *   * 描述：观察MyThread类的run方法上加锁synchroni...
每天一例多线程[day23]-----Disruptor的两种简单实现
抱愚守拙，持之以恒；不问结果，相信过程.
06-14 2103
在Disruptor中，Ringbuffer存放的数据可以被称作“trade”，即交易或者订单。在之前HelloWorld的例子中，我们获取disruptor实例，然后调用getRingbuffer()来获取RingBuffer，其实在很多时候，我们可以直接使用RingBuffer，以及其他的API操作。...
每天一例多线程[day24]-----Disruptor之单一生产者多消费者
抱愚守拙，持之以恒；不问结果，相信过程.
06-15 2751
在复杂场景下，希望一个生产者生产的数据放入RingBuffer后，能够被多个消费者消费，至于消费的方式，可能各有不同，比如菱形结构、六边形结构、顺序执行。接下来我们一一介绍菱形结构：说明：P1生产的数据给C1和C2并行执行完成后，再交给C3执行。代码：Handler1：设置了事先名称h1import com.lmax.disruptor.EventHandler; import com.lmax....
每天一例多线程[day25]-----Disruptor之多生产者多消费者
抱愚守拙，持之以恒；不问结果，相信过程.
06-16 2634
模拟一个多生产者（比如100个）生产订单（每个生产者生产100个订单），3个消费者消费订单的场景Order：public class Order { private String id;//ID private String name; private double price;//金额 public String getId() { return id; } ...
每天一例多线程[day3]-----synchronized与一个对象多个方法一把锁
抱愚守拙，持之以恒；不问结果，相信过程.
06-03 895
package com.jeff.base.sync003; /** * 一个对象多个方法一把锁 * * 对象锁的同步和异步问题 * @author jeff * */ public class MyObject { /** * 同步方法 */ public synchronized void method1(){ try { System.out.pr...
Day9----Spark概述
m0_66098020的博客
06-17 1555
​ 可以看到，在数据计算层，作为Hadoop核心组成的MapReduce可以结合Hive通过类SQL的方式进行数据的离线计算（当然也可以编写独立的MapReduce应用程序进行计算）；而Spark既可以做离线计算（Spark SQL），又可以做实时计算（Spark Streaming），它们底层都使用的是Spark的核心（Spark Core）。
传智播客-Java多线程-day04
w44gq2q44w的专栏
09-21 1039
---------------------- android培训、java培训、期待与您交流！ ---------------------- ------1102线程 继承Thead类 class Demo extends Thread 步骤： 1.定义类继承Thread 2.复写Thread类中的run方法  目的：将自定义代码存储在run方法中，让线程运行。 3.调用线程的st
中联软博--高级软件架构设计-培训讲义
07-10
2. **开发多条线索**：探讨多线程或多进程等并行处理技术在软件开发中的应用。 3. **架构的重要性**：分析架构对于软件系统的重要意义及其对整体性能的影响。 4. **软件架构的重构**：介绍软件架构在生命周期中可能...
侯捷- -深入浅出MFC
07-28
多线程程序设计实例 第2章 C++的重要性质 类及其成员——谈封装（encapsulation） 基类与派生类：谈继承（Inheritance） this指针 虚拟函数与多态（Polymorphism） 类与对象大解剖 Object slicing与虚拟函数 静态...
VC++常用的共用函数100多页
05-21
◆如何建立一个线程◆ 24 ◆如何让窗口产生一个图标（从应用程序资源中取出）◆ 24 ◆如何得到一个edit的录入的值◆ 24 ◆如何启动TIMER事件◆ 25 ◆如何使用ctrllist控件实现表格◆ 25 ◆如何从INI文件中得到值◆ ...
工业视觉智能-分割模型基础知识
08-18
根据《阿里云工业视觉智能高级工程师ACP认证免费课程》（https://edu.aliyun.com/course/3128115/lesson/342981389）创建的个人笔记
计算机毕业设计jsp高考志愿选择辅助系统idea论文
08-18
计算机毕业设计jsp高考志愿选择辅助系统idea论文
分享一款特别好看特别美的樱花博客前端页面
08-18
分享一款特别好看特别美的樱花博客前端页面
电脑软件：圆形印章生成.exe
最新发布
08-18
电脑软件：圆形印章生成.exe
Objective-C详解：Cocoa多线程与GCD高效实践
进程间通信相对复杂，而线程间通信则更为便捷。 iOS提供了多种多线程解决方案： 1. **NSThread**: Apple的原生线程库，允许开发者手动创建和管理线程。虽然直观易用，但对多核支持和任务调度不如GCD精细。 2. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值