使用BlockingQueue实现生产者和消费者模型

代码如下：

package test1;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

//首先新建Donwload类，在该类中模拟视频数据下载的过程，
//其中BlockingQueue对象则是在缓冲区，Donwload对象负责向该缓冲区存储数据，代码如下所示：
class DownLoad implements Runnable{
private BlockingQueue<Object> queue;

public DownLoad(BlockingQueue<Object> queue){
this.queue = queue;
}

//将下载好的视频文件放在缓冲队列等待播放
public void run(){
while(true){
try {
System.out.println("下载完成:" + index + "%");
queue.put(produce());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

//下载视频内容(Object类型)--每隔1秒下载1%
int index = 1;
public Object produce(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "视频数据:" + (index++) +"%";
}
}

//新建类Player，在该类中实现模拟播放视频的过程，
//其中BlockingQueue对象也是在上文中提到的缓冲区，Player对象负责从该缓冲区中取数据，代码如下所示：
class Player implements Runnable{
private BlockingQueue<Object> queue;

public Player(BlockingQueue<Object> queue){
this.queue = queue;
}

//将下载好的视频文件在缓冲队列中取出来--取出一次播放1秒钟
public void run(){
while(true){
try {
play(queue.take());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

//播放视频内容(Object类型)--每隔1秒播放1%
public void play(Object obj){
System.out.println("正在播放:"+obj);
}
}

//生产者和消费者模型
//测试类--在该类的main方法中，创建缓冲区BlockingQueue对象并将该对象传给下载器和播放器，
//这样就保证了下载器和播放器使用了相同的缓冲区。代码如下所示：
public class Demo04 {
public static void main(String[] args) {
BlockingQueue<Object> queue = new ArrayBlockingQueue<Object>(3);
//三个线程体
DownLoad down = new DownLoad(queue);
Player c1 = new Player(queue);
Player c2 = new Player(queue);

//一个线程负责下载，两个线程负责播放
new Thread(down).start();
new Thread(c1).start();
new Thread(c2).start();

}
}测试结果如下：
下载完成:1%
下载完成:2%
正在播放:视频数据:1%
下载完成:3%
正在播放:视频数据:2%
下载完成:4%
正在播放:视频数据:3%
下载完成:5%
正在播放:视频数据:4%
下载完成:6%
正在播放:视频数据:5%
正在播放:视频数据:6%
下载完成:7%
下载完成:8%
正在播放:视频数据:7%

注意事项：
从测试结果的输出结果可以看出，只有下载数据完成后该数据才能播放，这是因为，

BlockingQueue内部使用两条队列，可允许两个线程同时向队列一个做存储，一个做取出操作。

如果BlockingQueue对象是空的，则从BlockingQueue对象取数据的操作将会被阻塞进入等待状态，直到BlockingQueue对象有数据进入则被唤醒。

同样，如果BlockingQueue对象是满的,任何试图向其存数据的操作也会被阻塞进入等待状态，直到BlockingQueue对象内有空间则会被唤醒继续操作，

这样，BlockingQueue对象保证并发安全的同时提高了队列的存取效率。