前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >线程的通信和封闭

线程的通信和封闭

作者头像
CodingDiray
发布2019-09-25 16:14:26
5110
发布2019-09-25 16:14:26
举报
文章被收录于专栏:Coding Diary

线程通信的方式

要想实现线程之间的协同, 如: 线程先后执行顺序, 获取某个线程的执行结果等, 涉及线程之间的相互通信, 分为下面四类

  • 文件共享
  • 网络共享
  • 变量共享
  • JDK提供的线程协调API 细分为:suspend/resume, wait/notify, park/unpark
文件共享
变量共享

线程协作 - JDK API

典型场景: 生产者 - 消费者模型 (线程阻塞, 线程唤醒) 示例: 线程1区买包子 , 没有包子, 则不执行。 线程2生产包子, 通知线程1继续执行

API - 被弃用的suspend和resume 调用suspend挂起目标线程, 通过resume可以恢复线程执行, 对调用顺序有要求,也要开发者自己注意锁的释放。这个被弃用的API, 容易死锁,也容易导致永久挂起。 代码示例:

代码语言:javascript
复制
  /** 正常的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、通知消费者");
}
代码语言:javascript
复制
  /** 死锁的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、通知消费者");
}
代码语言:javascript
复制
  /** 先执行resume再执行suspend导致程序永久挂起的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机制

这些方法只能由同一对象锁的线程持有者调用,也就是写在同步代码块里面, 否则会抛出IllegalMonitorStateException异常。 wait方法导致当前线程等待, 加入该对象的等待集合中, 并且放弃当前持有的对象锁 notify/notifyAll唤醒一个/所有正在等待这个对象锁的线程 注意: 虽然wait会自动解锁, 但对顺序有要求, 如果在notify被调用之后, 才开始wait方法的调用, 线程会永远处于WAINTING状态 代码示例:

代码语言:javascript
复制
/** 正常的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、通知消费者");
}
}
代码语言:javascript
复制
/** 会导致程序永久等待的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则等待“许可”, unpark方法为指定线程提供“许可”。 不要求park和unpark方法的调用顺序。 多次调用unpark后再调用park, 线程会直接运行, 但不会叠加, 也就是说, 连续多次调用park方法, 第一次会拿到“许可”直接运行, 后续调用会进入等待。 注意: park/unpark 对调用顺序没有要求, 但是并不会释放锁 代码示例:

代码语言:javascript
复制
/** 正常的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、通知消费者");
}
代码语言:javascript
复制
 /** 死锁的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、通知消费者");
}

伪唤醒

之前代码中用if语句来判断是否进入等待是错误的 官方建议应该在循环中检查条件,原因是处于等待状态的线程可能会收到错误警报和伪唤醒, 如果不在循环中检查等待条件, 程序就会在没有满足结束条件的情况下退出 伪唤醒 :指线程并非因为notify, notifyAll, unpark等API调用而唤醒, 是更底层的原因导致的。

线程封闭

多线程访问共享可变数据时,并不是所有的时候,都要用到共享数据, 所以线程封闭的概念就提了出来。 所谓线程封闭, 就是指数据都封闭在各自的线程之中, 不需要不需要同步。线程封闭的具体的实现主要有ThreadLocal局部变量

ThreadLocal

ThreadLocal是Java里一种特殊的变量,一个线程级别的变量,每个线程都有一个自己独立的ThreadLocal变量。它的竞争条件被彻底消除, 在并发模式下是绝对安全的。 用法:ThreadLocal<T> var = new ThreadLocal<T>(); 会自动在每个线程上创建一个T的副本, 副本之间彼此独立,互不影响。 可以用ThreadLocal存储一些参数,以便在线程中多个方法中使用, 用来代替方法传参的的做法 代码示例:

代码语言:javascript
复制
/** 线程封闭示例 */
public class Demo6 {
/** threadLocal变量,每个线程都有一个副本,互不干扰 */
public static ThreadLocal<String> value = new ThreadLocal<>();
/**
* threadlocal测试   *
* @throws Exception
*/
public void threadLocalTest() throws Exception {
// threadlocal线程封闭示例    value.set("这是主线程设置的123"); // 主线程设置值    String v = value.get();
System.out.println("线程1执行之前,主线程取到的值:" + v);
new Thread(
new Runnable() {
@Override
public void run() {
String v = value.get();
System.out.println("线程1取到的值:" + v);
// 设置 threadLocal
value.set("这是线程1设置的456");
v = value.get();
System.out.println("重新设置之后,线程1取到的值:" + v);
System.out.println("线程1执行结束");
}
})
.start();
Thread.sleep(5000L); // 等待所有线程执行结束    v = value.get();
System.out.println("线程1执行之后,主线程取到的值:" + v);
}
public static void main(String[] args) throws Exception {
new Demo6().threadLocalTest();
}
}

输出结果:

代码语言:javascript
复制
线程1执行之前,主线程取到的值:这是主线程设置的123
线程1取到的值:null
重新设置之后,线程1取到的值:这是线程1设置的456
线程1执行结束
线程1执行之后,主线程取到的值:这是主线程设置的123

栈封闭

局部变量的固有属性之一就是封闭在线程中 它们位于执行线程的栈中, 其他线程无法访问这个栈

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2019-07-10,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Coding Diary 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 线程通信的方式
    • 文件共享
      • 变量共享
      • 线程协作 - JDK API
      • wait/notify机制
      • park/unpark机制
      • 伪唤醒
      • 线程封闭
      • ThreadLocal
      • 栈封闭
      领券
      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档