使用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对象保证并发安全的同时提高了队列的存取效率。