java 线程 生产者-消费者与队列,任务间使用管道进行输入、输出 解说演示样例 --thinking java4
package org.rui.thread.block2; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue; import org.rui.thread.LiftOff; /**
* 生产者-消费者与队列
*
* @author lenovo
*
*/ class LiftOffRunner implements Runnable { private BlockingQueue<LiftOff> rockets; public LiftOffRunner(BlockingQueue<LiftOff> b) {
rockets = b;
} //加入一个任务到队列
public void add(LiftOff lo) {
//将指定元素插入此队列中(假设马上可行且不会违反容量限制),
try {
rockets.put(lo);
} catch (InterruptedException e) {
e.printStackTrace();
} } @Override
public void run() { try {
while (!Thread.interrupted()) {
// 获取并移除此队列的头部,在元素变得可用之前一直等待(假设有必要)。
LiftOff rocket = rockets.take();
rocket.run();
} } catch (InterruptedException e) {
System.out.println("中断退出");
}
System.out.println("x exiting liftOffRunner"); }
} public class TestBlockingQueues { static void getkey() {
try {
// compensate for windows/linux difference in the
// 回车键产生的结果
new BufferedReader(new InputStreamReader(System.in)).readLine();
} catch (IOException e) {
e.printStackTrace();
}
} static void getkey(String message) {
System.out.println(message);
getkey();
} static void tets(String msg, BlockingQueue<LiftOff> queue) {
System.out.println(msg);
LiftOffRunner runner = new LiftOffRunner(queue); //启动一个线程
Thread t = new Thread(runner);
t.start(); for (int i = 0; i < 5; i++) {
//加入任务到LiftOffRunner队列中
runner.add(new LiftOff(5));
} //输入控制台
getkey("press 'enter' (" + msg + ")");
t.interrupt();
System.out.println(" 完了 " + msg + "test"); } public static void main(String[] args) {
tets("LinkedBlockingQueue", new LinkedBlockingQueue<LiftOff>());// unlimited // size
tets("ArrayBlockingQueue", new ArrayBlockingQueue<LiftOff>(3));// fied // size
tets("SynchronousQueue", new SynchronousQueue<LiftOff>());// size of 1 } }
package org.rui.thread.block2; import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit; /**
* 吐司BlockingQueue
* @author lenovo
*
*/ class Toast {
public enum Status {
DRY/* 干的 */, BUTTERED/* 涂黄油 */, JAMMED// 果酱
} private Status status = Status.DRY;
private final int id; public Toast(int idn) {
id = idn;
} public void butter() {
status = Status.BUTTERED;
} public void jam() {
status = Status.JAMMED;
} public Status getStatus() {
return status;
} public int getId() {
return id;
} public String toString() {
return "Toast " + id + ":" + status;
}
} /**
* 吐司队列
*
* @author lenovo
*
*/
class ToastQueue extends LinkedBlockingQueue<Toast> {
} class Toaster implements Runnable {
private ToastQueue toastQueue;
private int count = 0;
private Random rand = new Random(47); public Toaster(ToastQueue tq) {
toastQueue = tq;
} @Override
public void run() {
try {
while (!Thread.interrupted()) {
TimeUnit.MILLISECONDS.sleep(100 + rand.nextInt(500));
// 制作 toast
Toast t = new Toast(count++);
System.out.println(t);
// insert into queue
toastQueue.put(t); }
} catch (InterruptedException e) {
System.out.println("Toaster interrupted");
}
System.out.println("toaster off");
}
} // apply butter to toast
class Butterer implements Runnable {
private ToastQueue dryQueue, butteredQueue; public Butterer(ToastQueue dry, ToastQueue buttered) {
dryQueue = dry;
butteredQueue = buttered;
} @Override
public void run() {
try { while (!Thread.interrupted()) {
// blocks until next piece of toast is available 块,直到下一块面包
Toast t = dryQueue.take();
t.butter();
System.out.println(t);
butteredQueue.put(t);
}
} catch (InterruptedException e) {
System.out.println("涂黄油 interrupted");
}
System.out.println("涂黄油 off");
} } // apply jam to buttered toast
class Jammer implements Runnable {
private ToastQueue butteredQueue, finishedQueue; public Jammer(ToastQueue butteredQueue, ToastQueue finishedQueue) {
this.butteredQueue = butteredQueue;
this.finishedQueue = finishedQueue;
} @Override
public void run() {
try { while (!Thread.interrupted()) {
// blocks until next piece of toast is available 块,直到下一块面包
Toast t = butteredQueue.take();
t.jam();
System.out.println(t);
finishedQueue.put(t); }
} catch (InterruptedException e) {
System.out.println("涂果酱 interrupted");
}
System.out.println("涂果酱 off");
} } // ////使用烤面包 consume the toast
class Eater implements Runnable {
private ToastQueue finishedQueue;
private int counter = 0; public Eater(ToastQueue finished) {
finishedQueue = finished;
} @Override
public void run() {
try { while (!Thread.interrupted()) {
Toast t = finishedQueue.take();
// verify that the toast is coming in order 确认面包来了
// and that all pieces are getting jammed ,全部碎片越来越挤
if (t.getId() != counter++
|| t.getStatus() != Toast.Status.JAMMED) {
System.out.println("===>>>>error" + t);
System.exit(1); } else {
System.out.println("吃!" + t);
} }
} catch (InterruptedException e) {
System.out.println("食者 interrupted");
}
System.out.println(" 食者 off");
}
} /**
* main
*
* @author lenovo
*
*/
public class ToastOMatic { public static void main(String[] args) throws InterruptedException {
ToastQueue dryQueue = new ToastQueue();
ToastQueue butteredQueue = new ToastQueue();
ToastQueue finishedQueue = new ToastQueue(); ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new Toaster(dryQueue));//烤面包
exec.execute(new Butterer(dryQueue, butteredQueue));//涂黄油
exec.execute(new Jammer(butteredQueue, finishedQueue));//上果酱
exec.execute(new Eater(finishedQueue));//吃
TimeUnit.SECONDS.sleep(5);
exec.shutdownNow(); }
}
/**output:
Toast 0:DRY
Toast 0:BUTTERED
Toast 0:JAMMED
吃!Toast 0:JAMMED
Toast 1:DRY
Toast 1:BUTTERED
Toast 1:JAMMED
吃!Toast 1:JAMMED
Toast 2:DRY
Toast 2:BUTTERED
Toast 2:JAMMED
吃!Toast 2:JAMMED
...
...
Toast 10:DRY
Toast 10:BUTTERED
Toast 10:JAMMED
吃!Toast 10:JAMMED
Toast 11:DRY
Toast 11:BUTTERED
Toast 11:JAMMED
吃!Toast 11:JAMMED
Toast 12:DRY
Toast 12:BUTTERED
Toast 12:JAMMED
吃!Toast 12:JAMMED
Toast 13:DRY
Toast 13:BUTTERED
Toast 13:JAMMED
吃!Toast 13:JAMMED
Toast 14:DRY
Toast 14:BUTTERED
Toast 14:JAMMED
吃!Toast 14:JAMMED
食者 interrupted
Toaster interrupted
食者 off
涂果酱 interrupted
涂果酱 off
涂黄油 interrupted
涂黄油 off
toaster off */
package org.rui.thread.block2; import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit; /**
* 任务间使用管道进行输入、输出
*
* @author lenovo
*
*/
class Sender implements Runnable {
private Random rand = new Random(47);
private PipedWriter out = new PipedWriter(); public PipedWriter getPipedWriter() {
return out;
} @Override
public void run() {
try {
while (true) {
for (char c = 'A'; c <= 'z'; c++) {
out.write(c);
TimeUnit.MILLISECONDS.sleep(rand.nextInt(500)); }
}
} catch (IOException e) {
System.out.println(e + " sender write Exception");
} catch (InterruptedException e) {
System.out.println(e + " sender sleep interrupted");
} } } class Receiver implements Runnable { private PipedReader in; public Receiver(Sender sender) throws IOException {
in = new PipedReader(sender.getPipedWriter());
} @Override
public void run() {
try {
while (true) {
// blocks until characters are there
System.out.println("Read:" + (char) in.read() + ","); }
} catch (IOException e) {
System.out.println(e+"receiver read execption");
} } } public class PipedIO {
// 接收器 Receiver
public static void main(String[] args) throws IOException, InterruptedException {
Sender sender = new Sender();
Receiver receiver = new Receiver(sender); ExecutorService exec=Executors.newCachedThreadPool();
exec.execute(sender);
exec.execute(receiver); TimeUnit.SECONDS.sleep(4);
exec.shutdownNow(); }
} /**outpt:
Read:A,
Read:B,
Read:C,
Read:D,
Read:E,
Read:F,
Read:G,
Read:H,
Read:I,
Read:J,
Read:K,
Read:L,
Read:M,
Read:N,
Read:O,
Read:P,
java.lang.InterruptedException: sleep interrupted sender sleep interrupted
Read:Q,
java.io.IOException: Write end deadreceiver read execption */
java 线程 生产者-消费者与队列,任务间使用管道进行输入、输出 解说演示样例 --thinking java4的更多相关文章
- TIJ -- 任务间使用管道进行输入/输出
1. 通过输入/输出在线程间进行通信通常很有用.提供线程功能的类库以“管道”的形式对线程间的输入/输出提供了支持.它们在Java输入/输出类库中的对应物就是PipedWriter类(允许任务向管道写) ...
- java 状态模式 解说演示样例代码
package org.rui.pattern; import junit.framework.*; /** * 为了使同一个方法调用能够产生不同的行为,State 模式在代理(surrogate)的 ...
- Java 8 时间日期库的20个使用演示样例
除了lambda表达式,stream以及几个小的改进之外,Java 8还引入了一套全新的时间日期API,在本篇教程中我们将通过几个简单的任务演示样例来学习怎样使用Java 8的这套API.Java对日 ...
- java 覆盖hashCode()深入探讨 代码演示样例
java 翻盖hashCode()深入探讨 代码演示样例 package org.rui.collection2.hashcode; /** * 覆盖hashcode * 设计HashCode时最重要 ...
- Java实现生产者消费者问题与读者写者问题
摘要: Java实现生产者消费者问题与读者写者问题 1.生产者消费者问题 生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从 ...
- LabVIEW之生产者/消费者模式--队列操作 彭会锋
LabVIEW之生产者/消费者模式--队列操作 彭会锋 本文章主要是对学习LabVIEW之生产者/消费者模式的学习笔记,其中涉及到同步控制技术-队列.事件.状态机.生产者-消费者模式,这几种技术在在本 ...
- LabVIEW之生产者/消费者模式--队列操作
LabVIEW之生产者/消费者模式--队列操作 彭会锋 本文章主要是对学习LabVIEW之生产者/消费者模式的学习笔记,其中涉及到同步控制技术-队列.事件.状态机.生产者-消费者模式,这几种技术在在本 ...
- java 线程、线程池基本应用演示样例代码回想
java 线程.线程池基本应用演示样例代码回想 package org.rui.thread; /** * 定义任务 * * @author lenovo * */ public class Lift ...
- java 线程 被相互排斥堵塞、检查中断演示样例解说----thinking java4
package org.rui.thread.block; /** * 被相互排斥堵塞 就像在interrupting.java中看到的,假设你偿试着在一个对象上调用其synchronized方法, ...
随机推荐
- npm中的 --save-dev
当你为你的模块安装一个依赖模块时,正常情况下你得先安装他们(在模块根目录下npm install module-name),然后连同版本号手动将他们添加到模块配置文件package.json中的依赖里 ...
- 洛谷P2391 白雪皑皑(并查集)
题目背景 “柴门闻犬吠,风雪夜归人”,冬天,不期而至.千里冰封,万里雪飘.空中刮起了鸭毛大雪.雪花纷纷,降落人间. 美能量星球(pty 在 spore 上的一个殖民地)上的人们被这美景所震撼.但是 p ...
- 云信 短信发送 demo
package com.dataTaskListener; import org.apache.commons.httpclient.Header; import org.apache.commons ...
- Android中使用GoogleMap的地理位置服务
写在前面:android中使用地理位置功能,可以借助Google给我们提供的框架,要是有地理位置功能,你需要引用Google Play Services,请在sdk manager中下载.如果你还要使 ...
- 图片加载AsyncTask并发问题
在列表控件中使用AsycnTask加载图片时,会带来并发问题. 如果每个子视图都触发一个AsyncTask,因为AsyncTask内部是一个线程池,并发触发时,不能确保每个子视图的AsyncTask都 ...
- App Store兼容性问题
app下载出现兼容性问题 项目支持9.0以上的系统 但是10.3的iphone5下载的一直是老版本app 下载时提示不兼容 导致无法正常使用 解决办法: 修改Build-Settings-> ...
- 函数GROUP_CONCAT
这不得不说是mysql中一个特别好用的函数,之前生写这种确实好麻烦..感谢mysql有了这么好的函数..嘿嘿 举个例子吧. s_student 表 stuinfo表 sql如下: ok,简单粗暴,就这 ...
- 【从零开始】【Java】【1】Git和svn
闲聊 干活快一年了吧,感觉工作中能干的事情也有一点了,但总有种不通透的感觉,查一个问题,能一路查出一堆不明白的东西. 之前新建过文档是记录点点滴滴的知识的,使用上没问题了,但原理什么的还是不懂,想了想 ...
- The features of Swift
The features of Swift are designed to work together to create a language that is powerful, yet fun t ...
- 简明git教程(单人版本)
最近开始写一个比较大的东西,所以需要用到git,之前一直在用金山快盘和乌龟搭建的SVN,最近想尝试一下git 1.安装 Ubuntu: sudo apt-get install git 老版本的Ubu ...