AI 助理
备案控制台
开发者社区 云计算 文章 正文

java.util.concurrent包(3)——线程间通信wait/notify和await/signal

2014-06-03 1515
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
一、线程如何停止
使用stop()不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()。正确的做法是而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。jdk1.5后提供了condition对象，这个对象的await()和singal()方法也可以达到线程通信的效果。

二、wait和notify实例
子线程循环10次，主线程循环100次。接着子线程循环10次，主线程循环100次。如此循环50次。摘自张孝祥老师线程视频源码。
public class TraditionalThreadCommunication
{
public static void main(String[] args)
{
final Business business = new Business();
new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub(i);
}
}
}).start();
for (int i = 1; i <= 50; i++)
{
business.main(i);
}
}
}

class Business
{
private boolean bShouldSub= true;

public synchronized void sub(int i)
{
while (!bShouldSub)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub thread sequence of " + j + ",loop of " + i);
}
bShouldSub = false;
this.notify();
}

public synchronizedvoid main(int i)
{
while (bShouldSub)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 100; j++)
{
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = true;
this.notify();
}
}

三、Condition实例
public class Condition1Test
{
public static void main(String[] args)
{
final BusinessLock business = new BusinessLock();
new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub(i);
}
}
}).start();
for (int i = 1; i <= 50; i++)
{
business.main(i);
}
}
}

class BusinessLock
{
private boolean bShouldSub = true;

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void sub(int i)
{
lock.lock();
try
{
while (!bShouldSub)
{
try
{
condition.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub thread sequence of " + j + ",loop of " + i);
}
bShouldSub = false;
condition.signal();
}
finally
{
lock.unlock();
}
}

public void main(int i)
{
lock.lock();
try
{
while (bShouldSub)
{
try
{
condition.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 100; j++)
{
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = true;
condition.signal();
}
finally
{
lock.unlock();
}
}
}

四、Condition实例扩展
三个线程相互通信，main循环100次，sub2循环10次，sub3循环10次。接着main循环100次，sub2循环10次，sub3循环10次。如此循环50次。
public class Condition2Test
{
public static void main(String[] args)
{
final BusinessLock2 business = new BusinessLock2();
new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.main(i);
}
}
}).start();

new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub2(i);
}
}
}).start();

new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub3(i);
}
}
}).start();
}
}


class BusinessLock2
{
private int bShouldSub = 1;

ReentrantLock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();

public void main(int i)
{
lock.lock();
try
{
while (bShouldSub != 1)
{
try
{
condition1.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 100; j++)
{
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = 2;
condition2.signal();
}
finally
{
lock.unlock();
}
}

public void sub2(int i)
{
lock.lock();
try
{
while (bShouldSub != 2)
{
try
{
condition2.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub2 thread sequence of " + j + ",loop of " + i);
}
bShouldSub = 3;
condition3.signal();
}
finally
{
lock.unlock();
}
}

public void sub3(int i)
{
lock.lock();
try
{
while (bShouldSub != 3)
{
try
{
condition3.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub3 thread sequence of " + j + ",loop of " + i);
}
bShouldSub = 1;
condition1.signal();
}
finally
{
lock.unlock();
}
}
}
关键词：
线程wait notify
线程wait
线程notify
Java线程
Java wait notify
it徐胖子
目录
相关文章
潇洒洒
|
1月前
|
安全 Java
Java中WAIT和NOTIFY方法调用时机的深层解析
在Java多线程编程中，`wait()`和`notify()`方法的正确使用对于线程间的协调至关重要。这两个方法必须在同步块或同步方法中调用，这一规定的深层原因是什么呢？本文将深入探讨这一机制。
潇洒洒
41 5
最好zzz
|
1月前
|
安全 Java 开发者
Java中WAIT和NOTIFY方法必须在同步块中调用的原因
在Java多线程编程中，`wait()`和`notify()`方法是实现线程间协作的关键。这两个方法必须在同步块或同步方法中调用，这一要求背后有着深刻的原因。本文将深入探讨为什么`wait()`和`notify()`方法必须在同步块中调用，以及这一机制如何确保线程安全和避免死锁。
最好zzz
44 4
众所周知
|
1月前
|
安全 Java 开发者
深入解读JAVA多线程：wait()、notify()、notifyAll()的奥秘
在Java多线程编程中，`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中，每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践，帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法，确保线程安全和高效的通信。
众所周知
70 9
进步`于辰
|
2月前
|
Java 调度
[Java]线程生命周期与线程通信
本文详细探讨了线程生命周期与线程通信。文章首先分析了线程的五个基本状态及其转换过程，结合JDK1.8版本的特点进行了深入讲解。接着，通过多个实例介绍了线程通信的几种实现方式，包括使用`volatile`关键字、`Object`类的`wait()`和`notify()`方法、`CountDownLatch`、`ReentrantLock`结合`Condition`以及`LockSupport`等工具。全文旨在帮助读者理解线程管理的核心概念和技术细节。
进步`于辰
43 1
[Java]线程生命周期与线程通信
众所周知
|
1月前
|
Java
JAVA多线程通信：为何wait()与notify()如此重要？
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式，使线程在条件不满足时进入休眠状态，并在条件满足时被唤醒，从而确保数据一致性和同步。相比其他通信方式，如忙等待，这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
众所周知
40 3
龙大吉
|
2月前
|
安全 Java
Java多线程通信新解：本文通过生产者-消费者模型案例，深入解析wait()、notify()、notifyAll()方法的实用技巧
【10月更文挑战第20天】Java多线程通信新解：本文通过生产者-消费者模型案例，深入解析wait()、notify()、notifyAll()方法的实用技巧，包括避免在循环外调用wait()、优先使用notifyAll()、确保线程安全及处理InterruptedException等，帮助读者更好地掌握这些方法的应用。
龙大吉
25 1
toKeep
|
7月前
|
Java
java面向对象——包+继承+多态（一）-2
java面向对象——包+继承+多态（一）
toKeep
49 3
toKeep
|
7月前
|
SQL Java 编译器
java面向对象——包+继承+多态（一）-1
java面向对象——包+继承+多态（一）
toKeep
43 2
vblltq7lxmh76
|
存储 Java C语言
Java面向对象进阶5——包和final（含源码阅读）
包在操作系统中其实就是一个文件夹。包是用来分门别类的管理技术，不同的技术类放在不同的包下，方便管理和维护
vblltq7lxmh76
108 0
Java面向对象进阶5——包和final（含源码阅读）
全聚德在逃烤鸭、
|
存储 Java
Java SE基础知识详解第[8]期—面向对象进阶（包、权限修饰符、抽象类、接口）
Java SE基础知识详解第[8]期—面向对象进阶（包、权限修饰符、抽象类、接口）
全聚德在逃烤鸭、
464 0
Java SE基础知识详解第[8]期—面向对象进阶（包、权限修饰符、抽象类、接口）

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    java小工具util系列2：字符串工具
  • 3
    Java爬虫：数据采集的强大工具
  • 4
    Java中的异常处理：从基础到高级
  • 5
    深入理解Java异常处理机制
  • 6
    Liunx部署java项目Tomcat、Redis、Mysql教程
  • 7
    Java爬虫：深入解析商品详情的利器
  • 8
    java实现从HDFS上下载文件及文件夹的功能，以流形式输出，便于用户自定义保存任何路径下
  • 9
    Java 异常处理：机制、策略与最佳实践
  • 10
    Java 中的正则表达式
  • 1
    探索Python中的并发编程：协程与多线程的比较
    93
  • 2
    多线程在编程中的重要性有什么？并以LabVIEW为例进行说明
    60
  • 3
    Java一分钟之线程池：ExecutorService与Future
    154
  • 4
    深入理解Java并发编程：线程安全与性能优化
    50
  • 5
    linux线程与进程的区别及线程的优势
    73
  • 6
    Java一分钟：线程协作：wait(), notify(), notifyAll()
    73
  • 7
    Java一分钟：线程同步：synchronized关键字
    217
  • 8
    Java一分钟：多线程编程初步：Thread类与Runnable接口
    106
  • 9
    多线程业务异步处理
    79
  • 10
    深入理解Java并发编程：线程安全与性能优化
    44

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Java开发手册（嵩山版）灵魂17问
  • Java开发者面试百宝书
  • 多IO线程优化版

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)