java 线程之间的协作 wait()与notifyAll()

package org.rui.thread.block;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

// wax蜡    电气自己主动方式
public class WaxOMatic {

	public static void main(String[] args) throws InterruptedException {
		Car car = new Car();
		ExecutorService exec = Executors.newCachedThreadPool();
		exec.execute(new WaxOff(car));
		exec.execute(new WaxOn(car));
		TimeUnit.SECONDS.sleep(5);
		exec.shutdownNow();// 中断全部任务
		// shutdownNow 试图停止全部正在运行的活动任务,暂停处理正在等待的任务,并返回等待运行的任务列表
	}
}

class Car {
	//表示 抛光 、上蜡的处理状态
	private boolean waxOn = false;

	// 上蜡
	public synchronized void waxed() {
		waxOn = true;// ready to buff
		notifyAll();
	}

	// 抛光
	public synchronized void buffed() {
		waxOn = false;// ready to another coat of wax
		notifyAll();
	}

	// wait 上蜡
	public synchronized void waitForWaxing() throws InterruptedException {
		while (waxOn == false) {
			wait();//挂起这个任务
		}
	}

	// wait 抛光
	public synchronized void waitForBuffing() throws InterruptedException {
		while (waxOn == true) {
			wait();//挂起这个任务
		}
	}
}

class WaxOn implements Runnable {
	private Car car;

	public WaxOn(Car c) {
		car = c;
	}

	@Override
	public void run() {
		try {
			while (!Thread.interrupted()) {
				System.out.println("wax on!");
				TimeUnit.MILLISECONDS.sleep(200);
				car.waxed();// 上蜡
				car.waitForBuffing();//等 抛光
			}
		} catch (InterruptedException e) {
			System.out.println("通过中断退出");
			// e.printStackTrace();
		}
		System.out.println("ending Wax on task");
	}

}

// /////////////////////

class WaxOff implements Runnable {
	private Car car;

	public WaxOff(Car c) {
		car = c;
	}

	@Override
	public void run() {
		try {
			while (!Thread.interrupted()) {
				car.waitForWaxing();//等 吐蜡
				System.out.println("wax off!");
				TimeUnit.MILLISECONDS.sleep(200);
				car.buffed();//抛光

			}
		} catch (InterruptedException e) {
			System.out.println("通过中断退出");
			// e.printStackTrace();
		}
		System.out.println("ending Wax Off task");
	}

}

/*output:(95% match)
wax on!
wax off!
wax on!
wax off!
wax on!
wax off!
wax on!
wax off!
wax on!
wax off!
wax on!
wax off!
wax on!
wax off!
wax on!
wax off!
wax on!
通过中断退出
ending Wax on task
通过中断退出
ending Wax Off task
*/

时间: 2024-08-04 12:23:56

java 线程之间的协作 wait()与notifyAll()的相关文章

java 线程之间通信以及notify与notifyAll区别。

jvm多个线程间的通信是通过 线程的锁.条件语句.以及wait().notify()/notifyAll组成. 下面来实现一个启用多个线程来循环的输出两个不同的语句. package com.app.thread; import javax.swing.plaf.SliderUI;/** * 看出问题来 * @author Gordon * */public class LockDemo { public static void main(String[] args) {//  System.o

java并发系列(二)-----线程之间的协作(wait、notify、join、CountDownLatch、CyclicBarrier)

在java中,线程之间的切换是由操作系统说了算的,操作系统会给每个线程分配一个时间片,在时间片到期之后,线程让出cpu资源,由其他线程一起抢夺,那么如果开发想自己去在一定程度上(因为没办法100%控制它)让线程之间互相协作.通信,有哪些方式呢? wait.notify.notifyAll 1.void wait( ) 导致当前的线程等待,直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法 2.void wait(long timeout) 导致当前的线程等待,直到

Java线程:并发协作-生产者消费者模型

对于多线程程序来说,不管任何编程语言,生产者消费者模型都是最经典的. 实际上,准确的说应该是"生产者-消费者-仓储"模型,离开了仓储,生产者消费者模型就显得没有说服力了. 对于此模型,应该明确以下几点: 生产者仅仅在仓储未满时候生产,仓满则停止生产. 消费者仅仅在仓储有产品时候才能消费,仓空则等待. 当消费者发现仓储没有产品的时候会通知生产者生产. 生产者在生产出可消费产品时候,应该通知消费者去消费. 此模型将要结合java.lang.Object的wait与notify,notify

漫谈并发编程(五):线程之间的协作

编写多线程程序需要进行线程协作,前面介绍的利用互斥来防止线程竞速是来解决线程协作的衍生危害的.编写线程协作程序的关键是解决线程之间的协调问题,在这些任务中,某些可以并行执行,但是某些步骤需要所有的任务都结束之后才能开动. wait()与notifyAll() wait()使你可以等待某个条件发生变化,wait()会在等待外部世界产生变化的时候将任务挂起,并且只有在notify()或notifyAll()发生时,即表示发生了某些感兴趣的事物,这个任务才会被唤醒并去检查所产生的变化. 调用sleep

黑马程序员————java线程之间的通信

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 多线程可以让我们同时共享一个资源,但如果在共享这个资源时需要彼此之间的联系怎么做呢? 经典实例:生产者与消费者. 问题描述,生产者每生产一个消费者就要取走一个,同时进行. 首先java为我们提供了一套等待唤醒机制,让线程与线程之间产生了联

java线程之间的通信

1.常用的方法 sleep()该线程进入等待状态,不释放锁 wait() 该线程进入等待状态,释放锁 notify() 随机唤醒一个线程 notifyAll() 唤醒全部线程 2.线程之间的通信 a.两个线程之间的通信 public class ThreadExchange { @Test public void test2Thread() { MyPrint myPrint = new MyPrint(); new Thread(new Runnable() { @Override publi

线程之间的协作(二)生产者与消费者

考虑这样一个饭店,它有一个厨师(Chef)和一个服务员(Waiter).这个服务员必须等待厨师准备好菜品.当厨师准备好时,他会通知服务员,之后服务员上菜,然后返回继续等待.这是一个任务协作的示例:厨师代表生产者,而服务员代表消费者.两个任务必须在菜品被生产和消费时进行握手,而系统必须以有序的方式关闭.下面是对这个叙述建模的代码: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;

Java线程之间通讯(三)

使用wait和notify方法实现了线程间的通讯,都是Object 类的方法,java所有的对象都提供了这两个方法 1.wait和notify必须配合synchronized使用 2.wait方法释放锁,notify方法不释放锁 import java.util.ArrayList; import java.util.List; public class ListAdd1 { private volatile static List list = new ArrayList(); public

java 线程 wait join sleep yield notify notifyall synchronized

韩梦飞沙  韩亚飞  [email protected]  yue31313  han_meng_fei_sha 休息方法 : 在指定时间内 让该线程 暂停, 不会释放 锁标志. 等待方法: 让 该 线程等待, 如果 有锁标志, 将会释放 锁标志. 唤醒当前对象锁的等待线程 用 通知 或者 通知所有 方法,  等待方法 和 通知 方法 必须在 同步 函数 或 同步 块 中 进行调用. yield 方法 yield 是  n. 产量:收益  vt. 屈服:出产,产生:放弃 的意思. 加入 方法