阻塞队列LinkedBlockingQueue和并发队列ConcurrentLinkedQueue

LinkedBlockingQueue:

public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable  

此队列按 FIFO（先进先出）排序元素。队列的头部 是在队列中时间最长的元素。队列的尾部 是在队列中时间最短的元素。新元素插入到队列的尾部，并且队列检索操作会获得位于队列头部的元素。

链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。可选的容量范围构造方法参数作为防止队列过度扩展的一种方法。如果未指定容量，则它等于Integer.MAX_VALUE。除非插入节点会使队列超出容量，否则每次插入后会动态地创建链接节点。

适用阻塞队列的好处：多线程操作共同的队列时不需要额外的同步，另外就是队列会自动平衡负载，即那边（生产与消费两边）处理快了就会被阻塞掉，从而减少两边的处理速度差距。

Demo:

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

public class Main {
    public static void main(String[] args) {
        // 建立一个装苹果的篮子
        Basket basket =  new Basket();
        ExecutorService service = Executors.newCachedThreadPool();
        Producer producer =  new Producer("生产者001", basket);
        Producer producer2 =  new Producer("生产者002", basket);
        Consumer consumer =  new Consumer("消费者001", basket);
        service.submit(producer);
        service.submit(producer2);
        service.submit(consumer);
        // 程序运行5s后，所有任务停止
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdownNow();

    }
}

/**
 *
 * 定义装苹果的篮子
 *
 */
class Basket {
    // 篮子，能够容纳3个苹果
    BlockingQueue<String> basket = new LinkedBlockingQueue<String>(3);
    int i=0;
    // 生产苹果，放入篮子
    public void produce() throws InterruptedException {
        // put方法放入一个苹果，若basket满了，等到basket有位置
        i++;
        basket.put("An apple"+i);
    }

    // 消费苹果，从篮子中取走
    public String consume() throws InterruptedException {
        // take方法取出一个苹果，若basket为空，等到basket有苹果为止(获取并移除此队列的头部)
        return basket.take();
    }
}

// 定义苹果生产者
class Producer implements Runnable {
    private String instance;
    private Basket basket;

    public Producer(String instance, Basket basket) {
        this.instance = instance;
        this.basket = basket;
    }

    public void run() {
        try {
            while (true) {
                // 生产苹果
                System.out.println("生产者准备生产苹果：" + instance);
                basket.produce();
                System.out.println("!生产者生产苹果完毕：" + instance);
                // 休眠300ms
                Thread.sleep(300);
            }
        } catch (InterruptedException ex) {
            System.out.println("Producer Interrupted");
        }
    }
}

// 定义苹果消费者
class Consumer implements Runnable {
    private String instance;
    private Basket basket;

    public Consumer(String instance, Basket basket) {
        this.instance = instance;
        this.basket = basket;
    }

    public void run() {
        try {
            while (true) {
                // 消费苹果
                System.out.println("消费者准备消费苹果：" + instance);
                System.out.println(basket.consume());
                System.out.println("!消费者消费苹果完毕：" + instance);
                // 休眠1000ms
                Thread.sleep(1000);
            }
        } catch (InterruptedException ex) {
            System.out.println("Consumer Interrupted");
        }
    }
}

生产者准备生产苹果：生产者001
消费者准备消费苹果：消费者001
生产者准备生产苹果：生产者002
!生产者生产苹果完毕：生产者002
!生产者生产苹果完毕：生产者001
An apple1
!消费者消费苹果完毕：消费者001
生产者准备生产苹果：生产者001
生产者准备生产苹果：生产者002
!生产者生产苹果完毕：生产者001
!生产者生产苹果完毕：生产者002
生产者准备生产苹果：生产者001
生产者准备生产苹果：生产者002
消费者准备消费苹果：消费者001
An apple2
!生产者生产苹果完毕：生产者001
!消费者消费苹果完毕：消费者001
生产者准备生产苹果：生产者001
消费者准备消费苹果：消费者001
An apple3
!消费者消费苹果完毕：消费者001
!生产者生产苹果完毕：生产者002
生产者准备生产苹果：生产者002
消费者准备消费苹果：消费者001
An apple4
!消费者消费苹果完毕：消费者001
!生产者生产苹果完毕：生产者001
生产者准备生产苹果：生产者001
消费者准备消费苹果：消费者001
An apple5
!消费者消费苹果完毕：消费者001
!生产者生产苹果完毕：生产者002
生产者准备生产苹果：生产者002
Producer Interrupted
Producer Interrupted
Consumer Interrupted

http://www.cnblogs.com/linjiqin/archive/2013/05/30/3108188.html

http://blog.csdn.net/ac903919/article/details/6967728