d
import java.util.concurrent.Exchanger;
/**
* 案例:服务员向原有空杯中不断倒水,消费者不断从原有装满水的杯中喝水。
* 当服务员倒满水和消费者喝完水时,两个杯子进行交换。一直这样周而复始。
*
* @author Administrator
*
*/
public class TestExchanger {
static Exchanger<Cup> exchanger = new Exchanger<Cup>();
static Cup emptyCup = new Cup(0);
static Cup fullCup = new Cup(100);
public static void main(String[] args) {
new Thread(new Waiter(3)).start();
new Thread(new Customer(6)).start();
}
/**
* 服务员
*
* @author Administrator
*
*/
static class Waiter implements Runnable {
int addSpeed = 1;
public Waiter(int addSpeed) {
this.addSpeed = addSpeed;
}
@Override
public void run() {
while (emptyCup != null) {
// 如果发现杯子中的水没有满,则往杯中加水。
try {
if (emptyCup.isFull()) {// 当emptyCup为装满水时并且fullCup为被喝完水时,进行交换。
// 当Waiter把杯子水装满后,与Customer交换杯子。
// exchange(emptyCup)中参数的emptyCup是waiter装满水后的,把装满水后的emptyCup参数传递给Cutomer线程。
// 并且返回Cutomer线程中fullCup给Waiter的emptyCup,这样就达到了交换效果。
emptyCup = exchanger.exchange(emptyCup);
System.out.println("Waiter: " + emptyCup.capacity);
} else {
emptyCup.addWaterToCup(3);
System.out.println("Waiter add " + addSpeed
+ " and current capacity is "
+ emptyCup.capacity);
Thread.sleep((long) (Math
.max(500, Math.random() * 2000)));
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 消费者
*
* @author Administrator
*
*/
static class Customer implements Runnable {
int drinkSpeed = 1;
public Customer(int drinkSpeed) {
this.drinkSpeed = drinkSpeed;
}
@Override
public void run() {
while (fullCup != null) {
// 如果发现杯子中的水没有满,则往杯中加水。
try {
if (fullCup.isEmpty()) {
// 水满后则交换子中的水
fullCup = exchanger.exchange(fullCup);
System.out.println("Customer: " + fullCup.capacity);
} else {
fullCup.drinkFormCup(drinkSpeed);
System.out.println("Customer drinked " + drinkSpeed
+ " and current capacity is "
+ fullCup.capacity);
Thread.sleep((long) (Math
.max(500, Math.random() * 2000)));
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class Cup {
private int capacity = 0;
public Cup(int capacity) {
this.capacity = capacity;
}
public void addWaterToCup(int i) {
capacity += i;
capacity = capacity > 100 ? 100 : capacity;
}
public void drinkFormCup(int i) {
capacity -= i;
capacity = capacity < 0 ? 0 : capacity;
}
public boolean isFull() {
return capacity == 100 ? true : false;
}
public boolean isEmpty() {
return capacity == 0 ? true : false;
}
}
}
d
分享到:
相关推荐
1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
本资源包含两个 pdf 文档,一本根据 Jakob Jenkov 最新博客 (http://tutorials.jenkov.com/java-util-concurrent/index.html) 整理的 java_util_concurrent_user_guide_en.pdf,一个中文翻译的 java_util_concurrent...
一、java.util.concurrent体系的主要大板块包含内容 二、Executors 三、Semaphor信号量 四、Exchanger线程交互 五、CyclicBarrier关卡模式 六、CountDownLatch计数器
文章目录简介类定义类继承构造函数两个主要方法具体的例子结语 简介 Exchanger是java 5引入的并发类,Exchanger顾名思义就是用来做交换的。...↳ java.util.concurrent.Exchanger Exchanger直接继承自Obj
1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
本资源包含两个 pdf 文档,一本根据 Jakob Jenkov 最新博客 (http://tutorials.jenkov.com/java-util-concurrent/index.html) 整理的 java_util_concurrent_user_guide_en.pdf,一个中文翻译的 java_util_concurrent...
java.util.concurrent包中的Exchanger类可用于两个线程之间交换信息。可简单地将Exchanger对象理解为一个包含两个格子的容器,通过exchanger方法可以向两个格子中填充信息。当两个格子中的均被填充时,该对象会自动...
JUC是java并发包java.util.concurrent的缩写,就是这么简单明了~~~ 在我们JDK的并发包中,提供了几个非常有用的并发工具类,比如:CountDownLatch 闭锁、CyclicBarrier 同步屏障、Semaphore 信号量,在线程之间...
本章主要介绍java.util.concurrent下给我们提供的线程并发工具类的作用和使用场景。 一、Fork/Join 1、分而治之与工作密取 Fork/Join框架体现了分而治之的思想,就是在必要的情况下,将一个大任务进行拆分(fork)成...