1.1.3 线程通讯

最新推荐文章于 2023-11-11 20:19:06 发布
最新推荐文章于 2023-11-11 20:19:06 发布
阅读量158 收藏
点赞数
分类专栏： 专题一：Java高性能编程专题 文章标签： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feng576654808/article/details/100082126
版权

1、通讯方式

      要想实现多个线程之间的协同，如：线程执行的先后顺序、获取某条线程的执行结果等等。

      涉及到线程之间的相互通讯，分为如下几类：

      1) 文件共享

      2) 网络共享

      3) 共享变量

      4) JDK提供的线程协调API

          细分为：suspend()/resume()、wait()/notify()、park()/nupark()

2、文件共享

3、变量共享

     

 

 

4、线程协作—JDK API

     JDK对需要多线程协作完成某一项任务的场景，提供了对应的API支持。

     多线程协作的经典场景：生产者--消费者模型。（线程阻塞、线程唤醒）

     示例：线程1去买包子，没有包子，则不再执行；线程2产出包子，产出后通知线程1执行。

     

     1)  API - 被弃用的 suspend()、resume()

         作用：调用suspend()挂起目标线程，通过调用resume()可以恢复线程执行。

         被弃用的主要原因是：容易写出死锁的代码。所以用wait/notify、park/unpark机制对它进行替代。

         

import java.util.concurrent.locks.LockSupport;


public class Demo6 {
	/** 包子店 */
	public static Object baozidian = null;
	
	// suspend()、resume()对调用顺序有要求，也要开发自己注意锁的释放。这个被弃用的API， 容易死锁，也容易导致永久挂起。

	/** 正常的suspend/resume */
	public void suspendResumeTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				Thread.currentThread().suspend();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		consumerThread.resume();
		System.out.println("3、通知消费者");
	}

	/** 死锁的suspend/resume。 suspend并不会像wait一样释放锁，故此容易写出死锁代码 */
	public void suspendResumeDeadLockTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				// 当前线程拿到锁，然后挂起
				synchronized (this) {
					Thread.currentThread().suspend();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		// 争取到锁以后，再恢复consumerThread
		synchronized (this) {
			consumerThread.resume();
		}
		System.out.println("3、通知消费者");
	}

	/** 导致程序永久挂起的suspend/resume */
	public void suspendResumeDeadLockTest2() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) {
				System.out.println("1、没包子，进入等待");
				try { // 为这个线程加上一点延时
					Thread.sleep(5000L);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 这里的挂起执行在resume后面
				Thread.currentThread().suspend();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		consumerThread.resume();
		System.out.println("3、通知消费者");
		consumerThread.join();
	}
	
	
	public static void main(String[] args) throws Exception {
		// 对调用顺序有要求，也要开发自己注意锁的释放。这个被弃用的API， 容易死锁，也容易导致永久挂起。
		// new Demo6().suspendResumeTest();
		// new Demo6().suspendResumeDeadLockTest();
		// new Demo6().suspendResumeDeadLockTest2();


	}
}

     2) API--wait()/notify()机制

        这些方法只能由同一个对象锁的持有者线程调用；也就是写在同步代码块里面，否则会抛出

        IllegalMonitorStateException异常。

        wait()方法会导致当前线程进入等待状态，加入该对象的等待集合中，并且放弃当前持有的对象锁。

        notify()/notifyAll()会唤醒一个或者所有正在等待当前对象锁的线程。

        注意：虽然线程调用wait()方法时会释放对象锁，但是对顺序有要求，如果在调用notify()之后再调用wait()方法，

                   会导致线程永远处于waiting状态。

       

import java.util.concurrent.locks.LockSupport;

/** 三种线程协作通信的方式：suspend/resume、wait/notify、park/unpark */
public class Demo6 {
	/** 包子店 */
	public static Object baozidian = null;

	// wait/notify要求再同步关键字里面使用，免去了死锁的困扰，但是一定要先调用wait，再调用notify，否则永久等待了

	/** 正常的wait/notify */
	public void waitNotifyTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				synchronized (this) {
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		}).start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}

	/** 会导致程序永久等待的wait/notify */
	public void waitNotifyDeadLockTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				try {
					Thread.sleep(5000L);
				} catch (InterruptedException e1) {
					e1.printStackTrace();
				}
				synchronized (this) {
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		}).start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}
	

	public static void main(String[] args) throws Exception {

		// wait/notify要求再同步关键字里面使用，免去了死锁的困扰，但是一定要先调用wait，再调用notify，否则永久等待了
		// new Demo6().waitNotifyTest();
		// new Demo6().waitNotifyDeadLockTest();


	}
}

     3）API-park()/unpark()机制

          线程调用park()则等待 “许可” ，nupark()方法为指定线程提供 “许可(permit)”。

          不要求park()与unpark()方法的调用顺序。

          多次调用unpark()方法之后调用park()，线程会执行运行。但不会叠加，也就是说，连续多次调用park()方法，

          第一次会拿到 “许可” 直接运行，后续调用park()会进入等待状态。

          注意：park()根本没有锁的概念，所以不会释放锁，故在同步代码块中使用时需要注意。

         

import java.util.concurrent.locks.LockSupport;

/** 三种线程协作通信的方式：suspend/resume、wait/notify、park/unpark */
public class Demo6 {
	/** 包子店 */
	public static Object baozidian = null;
	
	
	// park/unpark没有顺序要求，但是park并不会释放锁，因为park没有锁的概念，所有再同步代码中使用要注意

	/** 正常的park/unpark */
	public void parkUnparkTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				LockSupport.park();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		LockSupport.unpark(consumerThread);
		System.out.println("3、通知消费者");
	}

	/** 死锁的park/unpark */
	public void parkUnparkDeadLockTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				// 当前线程拿到锁，然后挂起
				synchronized (this) {
					LockSupport.park();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		// 争取到锁以后，再恢复consumerThread
		synchronized (this) {
			LockSupport.unpark(consumerThread);
		}
		System.out.println("3、通知消费者");
	}

	public static void main(String[] args) throws Exception {
		

		// park/unpark没有顺序要求，但是park并不会释放锁，所有再同步代码中使用要注意
		// new Demo6().parkUnparkTest();
		// new Demo6().parkUnparkDeadLockTest();

	}
}

5、伪唤醒

      警告！上面代码使用了if语句判断线程是否进入等待状态，是错误的！

      官方建议，应该在循环中检查等待条件；原因是处于等待状态的线程可能会收到错误警报和伪唤醒。

      如果不在循环中检查等待条件，程序就会在没有满足条件的情况下退出。

      伪唤醒是指线程并非因为notify、notifyAll、unpark等API调用而唤醒，是更底层的原因导致的。

     

		//wait()
		synchronized(obj){
			while(<条件判断>){
				obj.wait()
				...
			}
		}
		
		//park()
		while(<条件判断>){
			LockSupport.park()
			...
		}

7、以上整体代码

import java.util.concurrent.locks.LockSupport;

/** 三种线程协作通信的方式：suspend/resume、wait/notify、park/unpark */
public class Demo6 {
	/** 包子店 */
	public static Object baozidian = null;
	
	// suspend()、resume()对调用顺序有要求，也要开发自己注意锁的释放。这个被弃用的API， 容易死锁，也容易导致永久挂起。

	/** 正常的suspend/resume */
	public void suspendResumeTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				Thread.currentThread().suspend();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		consumerThread.resume();
		System.out.println("3、通知消费者");
	}

	/** 死锁的suspend/resume。 suspend并不会像wait一样释放锁，故此容易写出死锁代码 */
	public void suspendResumeDeadLockTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				// 当前线程拿到锁，然后挂起
				synchronized (this) {
					Thread.currentThread().suspend();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		// 争取到锁以后，再恢复consumerThread
		synchronized (this) {
			consumerThread.resume();
		}
		System.out.println("3、通知消费者");
	}

	/** 导致程序永久挂起的suspend/resume */
	public void suspendResumeDeadLockTest2() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) {
				System.out.println("1、没包子，进入等待");
				try { // 为这个线程加上一点延时
					Thread.sleep(5000L);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 这里的挂起执行在resume后面
				Thread.currentThread().suspend();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		consumerThread.resume();
		System.out.println("3、通知消费者");
		consumerThread.join();
	}
	
	// wait/notify要求再同步关键字里面使用，免去了死锁的困扰，但是一定要先调用wait，再调用notify，否则永久等待了

	/** 正常的wait/notify */
	public void waitNotifyTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				synchronized (this) {
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		}).start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}

	/** 会导致程序永久等待的wait/notify */
	public void waitNotifyDeadLockTest() throws Exception {
		// 启动线程
		new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				try {
					Thread.sleep(5000L);
				} catch (InterruptedException e1) {
					e1.printStackTrace();
				}
				synchronized (this) {
					try {
						System.out.println("1、进入等待");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println("2、买到包子，回家");
		}).start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		synchronized (this) {
			this.notifyAll();
			System.out.println("3、通知消费者");
		}
	}
	
	
	// park/unpark没有顺序要求，但是park并不会释放锁，所有再同步代码中使用要注意

	/** 正常的park/unpark */
	public void parkUnparkTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				LockSupport.park();
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		LockSupport.unpark(consumerThread);
		System.out.println("3、通知消费者");
	}

	/** 死锁的park/unpark */
	public void parkUnparkDeadLockTest() throws Exception {
		// 启动线程
		Thread consumerThread = new Thread(() -> {
			if (baozidian == null) { // 如果没包子，则进入等待
				System.out.println("1、进入等待");
				// 当前线程拿到锁，然后挂起
				synchronized (this) {
					LockSupport.park();
				}
			}
			System.out.println("2、买到包子，回家");
		});
		consumerThread.start();
		// 3秒之后，生产一个包子
		Thread.sleep(3000L);
		baozidian = new Object();
		// 争取到锁以后，再恢复consumerThread
		synchronized (this) {
			LockSupport.unpark(consumerThread);
		}
		System.out.println("3、通知消费者");
	}

	public static void main(String[] args) throws Exception {
		// 对调用顺序有要求，也要开发自己注意锁的释放。这个被弃用的API， 容易死锁，也容易导致永久挂起。
		// new Demo6().suspendResumeTest();
		// new Demo6().suspendResumeDeadLockTest();
		// new Demo6().suspendResumeDeadLockTest2();

		// wait/notify要求再同步关键字里面使用，免去了死锁的困扰，但是一定要先调用wait，再调用notify，否则永久等待了
		// new Demo6().waitNotifyTest();
		// new Demo6().waitNotifyDeadLockTest();

		// park/unpark没有顺序要求，但是park并不会释放锁，所有再同步代码中使用要注意
		// new Demo6().parkUnparkTest();
		// new Demo6().parkUnparkDeadLockTest();

	}
	
}

 

 

 

 

「南小鸟」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ChiaSetup-1.1.3.exe
05-03
ChiaSetup-1.1.3.exe 1.1.3
JavaSE笔记（六）多线程
qq_25928447的博客
10-25 1546
Java多线程 **注意：**本章节会涉及到 操作系统 相关知识。 在了解多线程之前，让我们回顾一下操作系统中提到的进程概念： 进程是程序执行的实体，每一个进程都是一个应用程序（比如我们运行QQ、浏览器、LOL、网易云音乐等软件），都有自己的内存空间，CPU一个核心同时只能处理一件事情，当出现多个进程需要同时运行时，CPU一般通过时间片轮转调度算法，来实现多个进程的同时运行。 在早期的计算机中，进程是拥有资源和独立运行的最小单位，也是程序执行的最小单位。但是，如果我希望两个任务同时进行，就必须运行两个进
关于Thread.sleep方法的一些使用
最新发布
不在同一频道上的呆子的博客
11-11 794
关于Thread.sleep方法的一些使用
JAVA线程通信
Waiter软件工作室
05-24 189
JDK提供的线程协调的API： 1、suspend、resume（已废弃） 2、wait、notify 3、park、unpark 官方建议在循环中检查等待条件，因为处于等待状态的线程可能会因为错误或伪唤醒导致线程在没有满足结束条件的情况下退出。 一、suspend、resume很容易死锁，所以被弃用； 正常情况下： Thread consumerThread = new Thread(() -> { if (needWait == null) { // ...
Thread线程类基本使用(下)
qq_61797201的博客
07-28 1295
前一篇文章主要介绍了如何创建新线程和如何查看Java进程中的线程信息等知识，这篇文章接着介绍关于Thread的一些构造方法及方法，这篇文章会用到。
EventBus 事件驱动
akumalzw的专栏
10-24 1311
EventBus 领域驱动
BootCMS v1.1.3
12-04
BootCMS是一个以php+MySQL进行开发的开源内容管理系统。
geodesy-1.1.3.jar
04-07
geodesy-1.1.3.jar
ClanTiger v1.1.3.zip
06-18
ClanTiger v1.1.3.zip
Chia-1.1.3.dmg
05-03
Chia-1.1.3.dmg 1.1.3 1.1.3 1.1.3
【并发】Java并发线程池底层原理详解与源码分析（上）
金鳞踏雨
11-27 511
线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。Executors 返回的线程池对象的弊端：1） FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。2.CachedThreadPool：允许的创建线程数量为 MAX_VALUE，可能会创建大量建大量的线程，从而导致 OOM
1.1.5 线程池原理
「南小鸟」的博客
08-27 162
为什么要用线程池？ 线程是不是越多越好？ 1、线程在Java中是一个对象，更是操作系统的资源，线程的创建、销毁都需要时间。 如果创建时间+销毁时间>执行任务的时间 就很不划算。 2、Java对象占用堆内存，操作系统线程占用系统内存，根据JVM规范，一条线程默认最大栈大小为1M， 这个栈空间是需要从系统内存中分配的。线程过多会消耗很多的内存。 3、...
关于多线程的一点笔记
threedong's blog
07-13 439
进程：系统正在运行的程序。一个进程必须有一条线程 线程：可以“同时”实现执行多个任务的工作。在计算机里没有绝对意义上的同时做。线程的工作室并发的 创建线程有两种方式 1，继承Thread     两点不足         1，由于继承Thread，当前类就不能扩展其他类。在实际开发项目麻烦         2，由于线程内部重写的run方法决定了当前的线程要执行的任务。导致线程只会做这件
关于C#使用Thread.Sleep(3000)问题
wobushijishuzhai的博客
10-29 1138
Task.Run(() => { modeld.val = str; string da = "data"; string ac = "{" + da.ToJson() + ":[" + modeld.ToJson() + "]}"; ...
Java 线程sleep() 和 wait()的区别
Hern（宋兆恒）
09-22 524
sleep(休眠) 和 wait(等待) 方法是 Java 多线程中常用的两个方法 区别1：使用限制 使用 sleep 方法可以让当前线程休眠，时间一到当前线程继续往下执行，在任何地方都能使用，但需要捕获 InterruptedException 异常。 try { Thread.sleep(3000L); } catch (InterruptedException e) { ...
理解 Thread.Sleep 函数
greystar的专栏
04-08 5693
转自http://www.cnblogs.com/ILove/archive/2008/04/07/1140419.html我们可能经常会用到 Thread.Sleep 函数来使线程挂起一段时间。那么你有没有正确的理解这个函数的用法呢？思考下面这两个问题：1、假设现在是 2008-4-7 12:00:00.000，如果我调用一下 Thread.Sleep(1000) ，在 2008-4-7
Java JDK 中提供的线程通信方式
热门推荐
hu10131013的博客
04-21 16万+
JDK中提供的线程通信方式 1、wait/notify方式 wait/notify要求在同步关键字中使用，避免了死锁现象，但是如果不先调用wait，而先调用notify的情况下，容易导致线程永久挂起 package com.milla.study.netbase.expert.concurrent; import java.util.Objects; import java.u...
nacos-server 1.1.3下载
10-29
您可以通过以下步骤下载Nacos Server 1.1.3： 1. 首先，打开Nacos官网（https://nacos.io/zh-cn/）。 2. 在官网页面上方的菜单栏中，找到“下载”选项，并点击进入下载中心页面。 3. 在下载中心页面中，可以看到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值