java concurrent系列2---BlockingQueue

BlockingQueue 阻塞队列，支持两个附加操作的 Queue，这两个操作是：检索元素时等待队列变为非空，以及存储元素时等待空间变得可用。

如果BlockingQueue是空的，从BlockingQueue取东西的操作将会被阻断进入等待状态直到BlocingkQueue进了新货才会被唤醒。
如果BlockingQueue是满的任何试图往里存东西的操作也会被阻断进入等待状态， 直到BlockingQueue里有新的空间才会被唤醒继续操作。

package concurrent;

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

public class BlockingQueueTest {

/**
* 定义装苹果的篮子
*/
public static class Basket {

// 篮子，能够容纳3个苹果
BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);

// 生产苹果，放入篮子
public void produce(int i) throws InterruptedException {
// put方法放入一个苹果，若basket满了，等到basket有位置再put
basket.put("An apple "+i);
System.out.println("生产者生产了苹果：" + i );
}

// 消费苹果，从篮子中取走
public String consume() throws InterruptedException {
// get方法取出一个苹果，若basket为空，等到basket有苹果为止
return basket.take();
}
}

// 　测试方法
public static void testBasket() {
// 建立一个装苹果的篮子
final Basket basket = new Basket();

// 定义苹果生产者
class Producer implements Runnable {
int i=0;
public void run() {
try {
while (true) {
// 生产苹果
basket.produce(i);
i++;
// 休眠300ms
Thread.sleep(300);
}
} catch (InterruptedException ex) {
}
}
}

// 定义苹果消费者
class Consumer implements Runnable {
public void run() {
try {
while (true) {
// 消费苹果
System.out.println("消费者消费苹果：" + basket.consume());
// 休眠1000ms
Thread.sleep(1000);
}
} catch (InterruptedException ex) {
}
}
}

ExecutorService service = Executors.newCachedThreadPool();
Producer producer = new Producer();
Consumer consumer = new Consumer();

service.submit(producer);//若只将该句注释，basket队列一直是空，消费者在basket.take()处将一直等待
service.submit(consumer);//若只将该句注释，生产者生产3个苹果后，basket队列已满，生产者在basket.put("An apple "+i)处将一直等待

// 程序运行5s后，所有任务停止
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
service.shutdownNow();
}

public static void main(String[] args) {
BlockingQueueTest.testBasket();
}

}