1 查看api 搜索关键词： BlockingQueue
可以看到具体实现类：
所有已知实现类：
ArrayBlockingQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue
2 概念理解： 一个队列(理解成数组)，一个人不停的放面包，一个人不停的取面包，当放满时，放队列阻塞，放面包的人等待； 当取面包到没有时，取动作阻塞，取面包的人等待；
3 使用jdk提供实现类，模拟阻塞效果：
package cn.itcast.heima2;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.locks.ReentrantLock;
/**
* 其内部代码 和自定义写法一样 也是弄出两个队列来
* public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = (E[]) new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
* @author zm
*
* 测试结果：
* Thread-0准备放数据!
Thread-0已经放了数据，队列目前有1个数据
Thread-1准备放数据!
Thread-1已经放了数据，队列目前有2个数据
Thread-2准备取数据!
Thread-2已经取走数据，数据为: 1 队列目前有1个数据
Thread-1准备放数据!
Thread-1已经放了数据，队列目前有2个数据
Thread-0准备放数据!
Thread-0已经放了数据，队列目前有3个数据
Thread-1准备放数据! ------------------------> 此时篮子满了， 放队列进入阻塞
Thread-0准备放数据!
Thread-2准备取数据!
Thread-2已经取走数据，数据为: 1 队列目前有2个数据 -----------------------> 此时取走了一个面包 篮子不满
Thread-1已经放了数据，队列目前有3个数据 -----------------------> 此时才能继续放面包
*
*/
public class BlockingQueueTest {
public static void main(String[] args) {
final BlockingQueue queue = new ArrayBlockingQueue(3); // 定义篮子为3个大小
for(int i=0;i<2;i++){ // 两个人，不停向篮子 放面包
new Thread(){
public void run(){
while(true){
try {
Thread.sleep((long)(Math.random()*1000));
System.out.println(Thread.currentThread().getName() + "准备放数据!");
queue.put(1);
System.out.println(Thread.currentThread().getName() + "已经放了数据，" +
"队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
new Thread(){
public void run(){ // 一个人 不停的从篮子中 取面包
while(true){
try {
//将此处的睡眠时间分别改为100和1000，观察运行结果
Thread.sleep(1000); //
System.out.println(Thread.currentThread().getName() + "准备取数据!");
Object object = queue.take();
System.out.println(Thread.currentThread().getName() + "已经取走数据，数据为: " + object +
" 队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
4 使用自定义阻塞队列方式，实现 存取篮子面包效果:
package thread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
*
* @author zm
* 结果：
向第0个篮子生产了一个面包，面包重量为 25g
从第0个篮子拿走了一个面包，面包重量为 25g
向第1个篮子生产了一个面包，面包重量为 73g
向第2个篮子生产了一个面包，面包重量为 40g
从第1个篮子拿走了一个面包，面包重量为 73g
向第3个篮子生产了一个面包，面包重量为 50g
向第4个篮子生产了一个面包，面包重量为 90g
从第2个篮子拿走了一个面包，面包重量为 40g
从第3个篮子拿走了一个面包，面包重量为 50g
向第5个篮子生产了一个面包，面包重量为 50g
向第6个篮子生产了一个面包，面包重量为 77g
从第4个篮子拿走了一个面包，面包重量为 90g
*
*
* 案例2： 两队人，一对不停像100个篮子生产面包，一对不停从篮子拿走面包(阻塞队列)
*
* 如果是我不停的生产面包放在篮子里，我不管消费者拿面包， notfull队列(篮子还没存放满面包队列 有自己独自的wait nodify)
* 而消费者不停的去从篮子里拿面包，而不管生产者生产了多少， notempty队列(篮子面包还没空队列 有自己独自的wait nodify)
* 那么这就是两个队列，
* notfull队列， 只管像篮子里放面包，当100个篮子满的时，放面包动作处于等待
* notempty队列，只管从篮子里拿面包，当100个篮子空的时，存面包动作处于等待
* 此时需要使用同一个lock的两个condition来实现第二个案例
*
*
* 注意： count表示当前面包真实个数(生产一个 同时下个线程拿走一个 那么count = 0)
* items: 存放面包篮子
* putptr, 生产面包后 存放在篮子的角标，
* takeptr，取走面包时，面包所在篮子的角标
*
*/
public class CommunicateWithConditionThread {
public static void main(String[] args) {
final BoundedBuffer boundedBuffer = new BoundedBuffer();
new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
Thread.sleep((long)(Math.random()*100));
boundedBuffer.put((int)(Math.random()*100));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
Thread.sleep((long)(Math.random()*100));
boundedBuffer.take();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}).start();
}
}
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition(); // 生产队列
final Condition notEmpty = lock.newCondition(); // 消费队列
final Object[] items = new Object[20];
int putptr, takeptr, count;
public void put(int x) throws InterruptedException {
lock.lock(); // 生产面包上锁
try {
while (count == items.length) // 当生产队列并发大到突然生产了100个面包时，生产队列等待
notFull.await();
// 否则执行生产面包操作， 不断向数组下一个单元格内放新面包
items[putptr] = x;
System.out.println("向第" + putptr + "个篮子生产了一个面包，面包重量为 " + x + "g" );
if (++putptr == items.length) putptr = 0;// 当存放的面包到达数组最后位置时，篮子存放面包位置又从0开始
++count; // 记录面包个数
notEmpty.signal();// 生产了面包，就立即通知消费队列去取走面包
} finally {
lock.unlock();// 生产面包完成 解锁 让下个生产执行
}
}
public Object take() throws InterruptedException {
lock.lock();// 取面包上锁
try {
while (count == 0) // 当消费队列消费并发过大，或者刚开始没生产出面包时，消费队列等待
notEmpty.await();
Object x = items[takeptr];
System.out.println("从第" + takeptr + "个篮子拿走了一个面包，面包重量为 " + x + "g" );
if (++takeptr == items.length) takeptr = 0;// 当取走面包到篮子最后一个位置时，重置，再从篮子最开始位置取面包
--count;// 记录面包个数 取走一次面包 个数减一
notFull.signal(); // 取走面包， 立即通知生产队列生产面包
return x;
} finally {
lock.unlock(); // 取面包完成 解锁 让下个取面包动作执行
}
5 使用阻塞队列方式，实现 打印日志提高效率:
// 原来写法，耗时16S
public class Thread16 {
/**
* 打印16个日志 耗时16S
*/
public static void main(String[] args) {
System.out.println("begin: " + (System.currentTimeMillis()/1000));
for(int i=0; i<16; i++){ // 不能改
String log = "" + (i + 1);// 不能改
parseLog(log);
}
}
public static void parseLog(String log){
System.out.println("log: " + (System.currentTimeMillis()/1000));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
修改程序代码，开四个线程让这16个对象在4秒钟打完
思路:
0创建容量16的队列
1 将16个任务增加到 阻塞队列中
2开启4个线程，每次从队列中获取数据
这样主线程不停的放， 并发来的4个线程不停的取， 你可以理解为并发一次来了4个线程，每个线程取到后内部打印1S操作仍旧不变，
执行4次，一共耗时4S完成原来16秒不用并发下的操作
主线程放log 和 子线程取log 之间用condtion notEmpty notFull 来实现阻塞
public class Test {
public static void main(String[] args){
// 0 创建容量只为1的队列
final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);
// 2 开启4个线程，每次从队列中获取数据
for(int i=0;i<4;i++){
new Thread(new Runnable(){
@Override
public void run() {
while(true){
try {
String log = queue.take();
parseLog(log);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
// 1 将16个任务在主线程中增加到阻塞队列中
System.out.println("begin:"+(System.currentTimeMillis()/1000));
for(int i=0;i<16;i++){ //这行代码不能改动
final String log = ""+(i+1);//这行代码不能改动
{
try {
queue.put(log);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Test.parseLog(log);
}
}
}
//parseLog方法内部的代码不能改动
public static void parseLog(String log){
System.out.println(log+":"+(System.currentTimeMillis()/1000));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
脑图：
- 大小: 11.8 KB
分享到：
相关推荐
包含 jdk1.5免安装、jdk1.6免安装、jdk1.8（32和64）
jdk1.5.exe jdk1.5 jdk1.5下载
绝版jdk1.5，非常不错的资源。用起来很好。是 Java语言对Bean类属性、事件的一种缺省处理方法。例如类A中有属性name,那我们可以通过getName,setName来得到其值或者设置新 的值。通过getName/setName来访问name属性，...
JDK1.5,JDK1.5
前几天上传过这个资源，因为是在jdk1.6上开发的， 测试了一下在jdk1.5上不能用, 今天重新用jdk1.5编译了一下, 这个是可以支持jdk1.5+的 将 pu-xlscommon-1.0.0.jar 添加到工程的 /lib 目录下 用法在附件中 XlsTest....
测试可用的linux版jdk1.5，jdk-1_5_0_19-linux-i586-rpm.bin
jdk 1.5 中文 api chm jdk 1.5 中文 api chm
JDK1.5 API完整版JDK1.5 API完整版JDK1.5 API完整版
jdk1.5.0.22 是jdk1.5的最后一版，jdk1.5 windows 64位官方正式版,绝对有效，jdk1.5 windows 64位官方正式版,绝对有效
jdk1.5.0.22 是jdk1.5的最后一版
jdk1.5压缩包 解压缩可用 用于Windows系统
详细介绍java对象的使用和说明详细介绍java对象的使用和说明详细介绍java对象的使用和说明详细介绍java对象的使用和说明详细介绍java对象的使用和说明
很实用的JAVA API中文参考文档，如果你开始讨厌HTML版本的API中文文档，试试这个吧，强大的索引功能使你开发更加愉快，分两卷，要都下了才能解压。
JDK1.5+1.6整合版（文件为txt文件，里面有百度网盘下载地址<文件太大所以用网盘>） 文件里含有1.5和1.6两个版本的JDK，并且附有一环境变量创建办法以及切换版本方法
Jdk1.5Doc_CN.chm Jdk1.5Doc_CN.chm Jdk1.5Doc_CN.chm Jdk1.5Doc_CN.chm
“JDK1.5”（开发代号猛虎）的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-else 循环，自动装包/拆包，枚举，可变参数, 静态导入
Java-jdk1.5安装包
Windows 64位环境的JDK1.5。Java SE Development Kit(jdk下载)是Java语言软件开发工具包，是整个Java的核心所在，一些开发应用都需要安装Java JDK环境。自从Java推出以来，JDK已经成为使用最广泛的Java SDK，JDK是...
现在有些资源需要使用JDK1.5 ，并且官网已经不可下载，故上传该版本
JDK1.5 全平台安装包下载 百度网盘资源 jdk-1_5_0_22-linux-amd64-rpm.bin jdk-1_5_0_22-linux-amd64.bin jdk-1_5_0_22-linux-i586-rpm.bin jdk-1_5_0_22-linux-i586.bin jdk-1_5_0_22-solaris-amd64...