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();
}
}
}
});
}
}