阻塞队列BlockingQueue

BlockingQueue最终会有四种状况，抛出异常、返回特殊值、阻塞、超时，下表总结了这些方法：

抛出异常     特殊值   阻塞      超时

插入 add(e) offer(e) put(e) offer(e, time, unit)
移除 remove() poll() take() poll(time, unit)
检查 element() peek() 不可用 不可用

BlockingQueue是个接口，有如下实现类：
1. ArrayBlockQueue：一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。创建其对象必须明确大小，像数组一样。
2. LinkedBlockQueue：一个可改变大小的阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。创建其对象如果没有明确大小，默认值是Integer.MAX_VALUE。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。
3. PriorityBlockingQueue：类似于LinkedBlockingQueue，但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序。
4. SynchronousQueue：同步队列。同步队列没有任何容量，每个插入必须等待另一个线程移除，反之亦然。

ArrayBlockQueue要明确设定大小，这里很容易就实现了消费者生产者模式

package queue;

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

public class BlockingQueueTest{ 
    public static void main(String[] args) throws InterruptedException { 
            BlockingQueue<Integer> bqueue = new ArrayBlockingQueue<Integer>(10); 
            for (int i = 0; i < 30; i++) { 
                    //将指定元素添加到此队列中 

                    Random random=new Random();
                    bqueue.put(random.nextInt()); 
                    System.out.println("向阻塞队列中添加了元素:" + random.nextInt(10)); 

            } 
            System.out.println(bqueue);
            System.out.println("程序到此运行结束，即将退出----"); 
    } 
}

LinkedBlockQueue好像跟ArrayBlockQueue差不多，文档说的是无限大，这个没有尝试，，，试了一下感觉比较重要的PriorityBlockingQueue，，这里通过设置任务线程的优先级，然后放入队列当中，在先执行队列中优先级高的任务线程

package queue;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;


class PrioritizedTask implements Runnable, Comparable<PrioritizedTask>
{
    private static Random rand=new Random(1000);
    private static int counter = 0;
    private int id = counter++;
    private int priority;
    private int index;

    public PrioritizedTask(int index,int priority) 
    {
        this.index=index;
        this.priority = priority;
    }

    @Override
    public int compareTo(PrioritizedTask o) {
        //复写此方法进行任务执行优先级排序
        return this.priority < o.priority ? 1
        : this.priority > o.priority ? -1 : 0;
    }

    @Override
    public void run() {
        //执行任务代码写在这里
        try {
            TimeUnit.MILLISECONDS.sleep(rand.nextInt(250));
        } catch (InterruptedException e) {

        }
    }

    @Override
    public String toString() {
        return id+"# [index="+index+" priority="+priority+"]";
    }

}
public class PriorityBlockingQueue2 {
    static Random r=new Random(47);

    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();//缓存线程池
        final PriorityBlockingQueue<PrioritizedTask> queue = new PriorityBlockingQueue<PrioritizedTask>();//优先级队列
        exec.execute(new Runnable() {//往队列里放任务

            @Override
            public void run() {
                // TODO Auto-generated method stub
                int i=0;
                while(true){
                    queue.put(new PrioritizedTask(i++,r.nextInt(10)));
                    try {
                        TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        });

        exec.execute(new Runnable() {

            @Override
            public void run() {//取出任务，执行任务
                // TODO Auto-generated method stub
                while(true){
                    try {
                        synchronized (this) {
                            System.out.print("total--"+queue.toString());
                            PrioritizedTask task=queue.take();
                            System.out.print("take-- "+task);
                            System.out.print(" left:-- ["+queue.toString()+"]");
                            task.run();
                        }
                        System.out.println();
                        try {
                            TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }
}