Java生产者消费者-基于LinkedBlockingQueue

LinkedBlockingQueue 基于链表的阻塞队列
其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据并缓存在队列内部，生产者返回。
只有当队列缓冲区达到最大值缓存容量时才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。
而LinkedBlockingQueue之所以能够高效的处理并发数据，还因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据以此来提高整个队列的并发性能。
在它内部, take和put操作本身是隔离的, 有若干个元素的时候, 一个在queue的头部操作, 一个在queue的尾部操作, 因此分别持有一把独立的锁。
作为开发者，我们需要注意的是，如果构造LinkedBlockingQueue对象，而没有指定其容量大小，LinkedBlockingQueue会默认一个的容量Integer.MAX_VALUE=2 ^31 - 1 = 2147483647
如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已被消耗殆尽了。
生产者

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable{
         BlockingQueue<String> queue;
         public Producer(BlockingQueue<String> queue) {
            this.queue=queue;
        }
         @Override
         public void run() {
             try {
                String temp=Thread.currentThread().getName();
          System.out.println("生产者生产了:"+Thread.currentThread().getName());
                queue.put(temp);//生产者传递消息给消费者
            } catch (Exception e) {
                e.printStackTrace();
            }
         }
}

消费者

public class Consumer implements Runnable{
         BlockingQueue<String> queue;
         public Consumer(BlockingQueue<String> queue) {
            this.queue=queue;
        }
         @Override
         public void run() {
             try {
                String temp=queue.take();//消费者接受生产者的消息
                System.out.println("消费者消费了："+temp);               
            } catch (Exception e) {
                e.printStackTrace();
            }
         }
}

测试代码

public class TestPRroducerConsumer {
public static void main(String[] args) {
    BlockingQueue<String> queue=new LinkedBlockingQueue<String>(2);//如果这里没有写2，就默认为最大，要避免出现这种情况。
    Producer p=new Producer(queue);
    Consumer c=new Consumer(queue);
    for (int i = 1; i <=5; i++) {
        new Thread(p,"产品"+i).start();
        new Thread(c,"Consumer"+i).start();
    }
}
}