线程协作

首先引入一段代码:

package 线程间数据共享;

import java.util.Date;

public class Watch {

	private static String time;

	static class Display extends Thread{
Time timeThread; Display(Time time) {
this.timeThread=time;
} @Override
public void run() {
if(time==null){ }
System.out.println(time);
}
} static class Time extends Thread{ @Override
public void run() {
time = new Date().toString();
}
} public static void main(String[] args) {
Time time = new Time();
time.start();
new Display(time).start();
}
}

结果显示为:

之后我们在if(time==null){ }语句代码块中添加,使其能够正常输出(输出结果不为null)
代码展示为:

package 线程间数据共享;

import java.util.Date;

public class Watch {

	private static String time;

	static class Display extends Thread{
Time timeThread;
Object object; Display(Time time) {
this.timeThread=time;
} @Override
public void run() {
if(time==null) {
try {
sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(time);
}
} static class Time extends Thread{ @Override
public void run() {
time = new Date().toString();
}
} public static void main(String[] args) {
final Object OBJECT = new Object();
Time time = new Time();
time.start();
new Display(time).start();
}
}

结果显示为:

我们通过sleep()方法实现了正常的输出,但是在实际操作过程中,我们无法判断sleep()中所需要限制的时间,因此我们需要通过另一种方法来实现:即使用join()方法,代码展示为:

package 线程间数据共享;

import java.util.Date;

public class Watch {

	private static String time;

	static class Display extends Thread{
Time timeThread;
Object object; Display(Time time) {
this.timeThread=time;
} @Override
public void run() {
if(time==null) {
try {
timeThread.join();//线程A执行“已死”线程B所调用的jion方法,则线程A不会阻塞。
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(time);
}
} static class Time extends Thread{ @Override
public void run() {
time = new Date().toString();
}
} public static void main(String[] args) {
final Object OBJECT = new Object();
Time time = new Time();
time.start();
new Display(time).start();
}
}

结果显示为:

如果不使用join()方法,我们还可以选择使用synchronized ()关键字的形式实现,代码展示为:

package 线程间数据共享;

import java.util.Date;

public class Watch {

	private static String time;

	static class Display extends Thread{
Time timeThread;
Object object; Display(Time time,Object object) {
this.timeThread=time;
this.object=object;
} @Override
public void run() {
if(time==null) {
synchronized (object) {
try {//如果没有synchronized关键字,则会出现报错
object.wait();//线程执行该方法,则该线程阻塞,知道调用notify方法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(time);
}
} static class Time extends Thread{
Object object;
Time(Object object){
this.object=object;
} @Override
public void run() {
time = new Date().toString();
synchronized (object) {
object.notify();
}
}
} public static void main(String[] args) {
final Object OBJECT = new Object();
Time time = new Time(OBJECT);
time.start();
new Display(time,OBJECT).start();
}
}

结果显示为:

Object类中解决线程间协作的方法

synchronized关键字只是起到了多个线程“串行”执行临界区中代码的作用,但是哪个线程先执行,哪个线程后执行依无法确定。Object类中的wait()、notify()和notifyAll()三个方法解决了线程间的协作问题,通过这三个方法的“合理”使用可以确定多线程中线程的先后执行顺序:
1、wait():对象锁调用了wait()方法会使当前持有该对象锁的线程处于线程等待状态同时该线程释放对对象锁的控制权,直到在其他线程中该对象锁调用notify()方法或notifyAll()方法时等待此对象锁的线程才会被唤醒。
2、notify():对象锁调用notify()方法就会唤醒在此对象锁上等待的单个线程。
3、notifyAll():对象锁调用notifyAll()方法就会唤醒在此对象锁上等待的所有线、程;调用notifyAll()方法并不会立即激活某个等待线程,它只能撤销等待线程的中断状态,这样它们就能够在当前线程退出同步方法或同步代码块法后与其它线程展开竞争,以争取获得资源对象来执行。

谁调用了wait方法,谁就必须调用notify或notifyAll方法,并且“谁”是对象锁。

使用Object类中的wait()、notify()和notifyAll()三个方法需要注意以下几点:
1、wait()方法需要和notify()或notifyAll()方法中的一个配对使用,且wait方法与notify()或notifyAll()方法配对使用时不能在同一个线程中(参见代码1)。
2、wait()方法、notify()方法和notifyAll()方法必须在同步方法或者同步代码块中使用,否则出现IllegalMonitorStateException 异常。
3、调用wait()方法、notify()方法和notifyAll()方法的对象必须和同步锁对象是一个对象。

sleep()方法和wait()方法区别

1、sleep()方法被调用后当前线程进入阻塞状态,但是当前线程仍然持有对象锁,在当前线程sleep期间,其它线程无法执行sleep方法所在临界区中的代码。

package 线程间数据共享;

import java.util.Date;

public class sleep和wait区别 {

		public static void main(String[] args) {
Object lockObj = new Object();
new PrintThread("1号打印机"+new Date(),lockObj).start();
new PrintThread("2号打印机"+new Date(),lockObj).start();
}
} class PrintThread extends Thread { private Object lockObj; public PrintThread(String threadName, Object lockObj) {
super(threadName);
this.lockObj = lockObj;
} @Override
public void run() {
synchronized (lockObj) {
System.out.println(getName());
try {
sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

结果显示为:

由此我们可以看出:当某台打印机执行临界区中的代码,输出线程名后由于调用了sleep方法,从而使得该打印机线程阻塞3秒,在这3秒期间因该打印机线程仍然持有对象锁,从而导致另一台打印机线程只能在3秒后才能执行临界区中的代码。(但是所执行的时间是相同的)
2、对象锁调用了wait()方法会使当前持有该对象锁的线程处于线程等待状态同时该线程释放对对象锁的控制权,在当前线程处于线程等待期间,其它线程可以执行wait方法所在临界区中的代码。

package 线程间数据共享;

import java.util.Date;

public class sleep和wait区别 {

		public static void main(String[] args) {
Object lockObj = new Object();
new PrintThread("1号打印机"+new Date(),lockObj).start();
new PrintThread("2号打印机"+new Date(),lockObj).start();
}
} class PrintThread extends Thread { private Object lockObj; public PrintThread(String threadName, Object lockObj) {
super(threadName);
this.lockObj = lockObj;
} @Override
public void run() {
synchronized (lockObj) {
System.out.println(getName());
try {
lockObj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

结果显示为:

wait()方法

代码一:

package 线程间数据共享;
class CounterThread extends Thread { private Object lockObj; public CounterThread(String threadName, Object lockObj) {
super(threadName);
this.lockObj = lockObj;
} @Override
public void run() {
int i = 1;
while (true) {
synchronized (lockObj) {
System.out.println(getName() + ":" + i);
try {
lockObj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
}
}
}
} public class Test { public static void main(String[] args) {
Object lockObj = new Object();
new CounterThread("1号计数器",lockObj).start();
new CounterThread("2号计数器",lockObj).start();
}
}

结果显示为:

尽管while(){xxx}循环是死循环,但由于对象锁lockObj调用了wait()方法,使得分别持有该lockObj对象锁的“1号计数器”线程和“2号计数器”线程处于线程等待状态,所以循环并没有继续下去
代码二:

package 线程间数据共享;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date; public class sleep和wait区别 { public static void main(String[] args) {
TimeThread timeThread = new TimeThread ();
timeThread.start(); synchronized (timeThread) {
try {
timeThread.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("main方法");//由于主线程进入了阻塞状态,所以该行代码不执行
}
} class TimeThread extends Thread{ @Override
public void run() {
DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
while (true) {
String currentTime = dateFormat.format(new Date());
System.out.println(currentTime);
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

结果显示为:

为什么时间线程没有进入阻塞状态呢?
timeThread变量所代表的对象充当对象锁,由于该代码在main方法中,也就是说将来由主线程执行临界区中的代码,也就是说主线程是持有对象锁的线程,主线程执行完“timeThread.wait()”代码后进入阻塞状态,是主线程进入阻塞状态而非时间线程,这也是main方法中“System.out.println(“main方法”);”代码不执行的原因。

notify()方法和notifyAll()方法

notify()方法

import java.text.SimpleDateFormat;
import java.util.Date; public class ElectronicWatch { String currentTime;
DisplayThread displayThread = new DisplayThread();
private static final Object lockObject = new Object(); public static void main(String[] args) {
new ElectronicWatch().displayThread.start();
} /**
* 该线程负责显示时间
*/
class DisplayThread extends Thread{ @Override
public void run() {
synchronized (lockObject) {
new TimeThread().start();
try {
lockObject.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(currentTime);
}
}
} /**
* 该线程负责获取时间
*/
class TimeThread extends Thread{ @Override
public void run() {
synchronized (lockObject) {
try {
sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String pattern = "yyyy-MM-dd HH:mm:ss";
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
currentTime = sdf.format(new Date());
lockObject.notify();
}
}
}
}

结果显示为:

notifyAll()方法

package 线程间数据共享;
class CounterThread extends Thread { private Object lockObj; public CounterThread(String threadName, Object lockObj) {
super(threadName);
this.lockObj = lockObj;
} @Override
public void run() {
int i = 1;
while (true) {
synchronized (lockObj) {
System.out.println(getName() + ":" + i);
try {
lockObj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
}
}
}
} class NotifyAllThread extends Thread { private Object lockObj; public NotifyAllThread(Object lockObj) {
this.lockObj = lockObj;
} @Override
public void run() {
synchronized (lockObj) {
System.out.println("notifyAll方法执行完毕");
lockObj.notifyAll();
}
}
} public class Test { public static void main(String[] args) {
Object lockObj = new Object();
new CounterThread("1号计数器", lockObj).start();
new CounterThread("2号计数器", lockObj).start(); try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} new NotifyAllThread(lockObj).start();
}
}

结果显示为:

如果调用的是notify方法,则只会唤醒在lockObj对象锁上等待的两个线程中的一个;
而调用notifyAll方法则会全部唤醒,尽管只调用一次
http://www.dtmao.cc/news_show_676906.shtml

Java中详述线程间协作的更多相关文章

  1. java中关于线程间协作所用关键字synchronized,wait,notify的用法

    wait/notify()关键字适用于一个线程通知另一个线程所需的条件状态已就绪,最常用于线程在循环中休眠直到获取特定条件的场景. 例如,一个线程一直等待直到队列中有一个组件能够处理:当组件添加到队列 ...

  2. java并发编程 线程间协作

    线程间协作 1. 等待和通知 等待和通知的标准形式 等待方: 获取对象锁 循环中判断条件是否满足,不调用wait()方法 条件满足执行业务逻辑 通知方: 获取对象所 改变条件 通知所有等待在对象的线程 ...

  3. Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  4. Java并发编程(十三)线程间协作的两种方式:wait、notify、notifyAll和Condition

    在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界资源(即队列)的占用权.因为生产者如果 ...

  5. Java多线程之线程的状态以及线程间协作通信导致的线程状态转换

      转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/6561589.html  一:线程的状态以及变化图 Java中线程中状态可分为五种:New(新建状态),Ru ...

  6. Java并发编程(八)线程间协作(上)

    多线程并发执行时,不同的线程执行的内容之间可能存在一些依赖关系,比如线程一执行a()方法和c()方法,线程二执行b()方法,方法a()必须在方法b()之前执行,而方法c()必须在方法b()之后执行.这 ...

  7. 19、Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  8. Java并发--线程间协作的两种方式:wait、notify、notifyAll和Condition

    在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界 ...

  9. java并发之线程间通信协作

    在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者模型:当队列满时,生产者需要等待队列有空间才能继续往里面放入商品,而在等待的期间内,生产者必须释放对临界 ...

随机推荐

  1. 风炫安全WEB安全学习第十八节课 使用SQLMAP自动化注入(二)

    风炫安全WEB安全学习第十八节课 使用SQLMAP自动化注入(二) –is-dba 当前用户权限(是否为root权限) –dbs 所有数据库 –current-db 网站当前数据库 –users 所有 ...

  2. 第9章 集合处理(数组、Map、Set)

    目录 1. 数组 1.1 创建数组 1.2 在数组两端添加删除元素 1.3 在数组任意位置添加.删除元素 delete删除数组元素无效 使用splice方法增.删.改元素 1.4 数组的常用操作 数组 ...

  3. js 必须为字母或下划线, 一旦创建不能修改

    <div class="form-group"> <label class="col-lg-2 control-label" for=&quo ...

  4. 【Java基础】面向对象下

    面向对象下 这一章主要涉及其他关键字,包括 this.super.static.final.abstract.interface.package.import 等. static 在 Java 类中, ...

  5. Lniux 入门:03 用户及文件权限管理

    1.1 实验内容 Linux 中创建.删除用户,及用户组等操作. Linux 中的文件权限设置. 1.2 实验知识点 Linux 用户管理 Linux 权限管理 通过第一节课程的学习,你应该已经知道, ...

  6. Python使用Protobuf&&如何赋值&&如何正反序列化

    前言 使用protobuf主要是两个步骤,序列化和反序列化. 关于Proto有哪些数据类型,然后如何编写,此处就不赘述了,百度一下有很多. 此文主要是总结,python使用protobuf的过程,如何 ...

  7. Oracle获取session的IP方法

    方法1 创建触发器:  create orreplace trigger login_on  alfterlogon on database  begin  dbms_application_info ...

  8. 电子邮箱、邮件地址、网站地址正则表达式!几个有用的RE、regex、regexp!

    几个常用的正则表达式! r"\w[-\w\.]*@\w[-\w]*(\.\w[-\w]*)+" 这个是电子邮件地址的. r"<TAG\b[^>]*<(. ...

  9. 奇技淫巧,还是正统功夫? - Python推导式最全用法

    前言 本文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理. PS:如有需要Python学习资料的小伙伴可以加点击下方链接自行获取 python免费学习资 ...

  10. 透过现象看本质:Java类动态加载和热替换

    摘要:本文主要介绍类加载器.自定义类加载器及类的加载和卸载等内容,并举例介绍了Java类的热替换. 最近,遇到了两个和Java类的加载和卸载相关的问题: 1) 是一道关于Java的判断题:一个类被首次 ...