PriorityblockingQueue类使用示例

PriorityblockingQueue是一个无界的阻塞队列，其api文档描述如下：
java.util.concurrent
类 PriorityBlockingQueue<E>
java.lang.Object
   java.util.AbstractCollection<E>
       java.util.AbstractQueue<E>
           java.util.concurrent.PriorityBlockingQueue<E>
类型参数：
E - 此 collection 中所保存元素的类型
所有已实现的接口：
Serializable, Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>
________________________________________
public class PriorityBlockingQueue<E>
extends AbstractQueue<E>
implements BlockingQueue<E>, Serializable
一个无界阻塞队列，它使用与类 PriorityQueue 相同的顺序规则，并且提供了阻塞获取操作。虽然此队列逻辑上是无界的，但是资源被耗尽时试图执行 add 操作也将失败（导致 OutOfMemoryError）。此类不允许使用 null 元素。依赖自然顺序的优先级队列也不允许插入不可比较的对象（这样做会导致抛出 ClassCastException）。
此类及其迭代器可以实现 Collection 和 Iterator 接口的所有可选 方法。iterator() 方法中提供的迭代器并不 保证以特定的顺序遍历 PriorityBlockingQueue 的元素。如果需要有序地进行遍历，则应考虑使用 Arrays.sort(pq.toArray())。此外，可以使用方法 drainTo 按优先级顺序移除 全部或部分元素，并将它们放在另一个 collection 中。
在此类上进行的操作不保证具有同等优先级的元素的顺序。如果需要实施某一排序，那么可以定义自定义类或者比较器，比较器可使用修改键断开主优先级值之间的联系。例如，以下是应用先进先出 (first-in-first-out) 规则断开可比较元素之间联系的一个类。要使用该类，则需要插入一个新的 FIFOEntry(anEntry) 来替换普通的条目对象。

 

 

 

解释：从该类的字面名字意思来看，这是一个含优先级的阻塞队列，没错的确是这样的。PriorityBlockingQueue作为一个队列，也是按先进先出的原则进行操作。队列中的对象与对象之间可以根据优先级别来比大小，所以队列中的对象可以继承Comparable类，重写compareTo（）方法，我这次之所以把这个类列出来进行描述是因为我的渲染平台项目中出现过这个类，并且还占有一定的重要地位，项目中用这个类实现任务的优先级别的动态改变从而实现渲染机优先处理哪个任务。下面是我的测试代码：

try {
			PriorityBlockingQueue<TaskSeg> waitSegs = new PriorityBlockingQueue<TaskSeg>();
			String inputpath = "D://s//sun//sun.max";
			String outputpath = "D://t//sun";
			String outputtype = "tga";
			String frames = "1-100";
			String rendsoft = "3dmax";
			int segnum = 10;
			String username = "bozai";
			String params = "";
			Task task = TaskControl.getInstance().createTask(inputpath, outputpath, outputtype,
					frames, rendsoft, segnum, username, 3, params);
			List<TaskSeg> segs = task.getSegs();
			System.out.println("------------------------------------------------------------------");
			int i = 0;
			for(TaskSeg seg : segs){
				i++;
				System.out.println("第"+i+"个分段："+seg.getSegs());
			}
			System.out.println("------------------------------------------------------------------\n");
			waitSegs.addAll(segs);
			segs.get(1).setPriority(4);
			segs.get(2).setPriority(5);//21-30:优先级为2
			segs.get(3).setPriority(6);//31-40:优先级为4
			segs.get(4).setPriority(7);
			segs.get(5).setPriority(8);
			segs.get(6).setPriority(9);
			segs.get(7).setPriority(10);
			segs.get(8).setPriority(11);
//			waitSegs.addAll(segs);
			int length = waitSegs.size();
			for(int j = 1;j<=length;j++){
				TaskSeg seg = waitSegs.poll();
				System.out.println("修改优先级后，第"+j+"个分段："+seg.getSegs()+",优先级为："+seg.getPriority());
			}
			System.out.println("---------------------------\n");
			waitSegs.add(segs.get(8));
			waitSegs.add(segs.get(2));
			waitSegs.add(segs.get(5));
			waitSegs.add(segs.get(0));
			waitSegs.add(segs.get(9));
			waitSegs.add(segs.get(1));
			waitSegs.add(segs.get(4));
			waitSegs.add(segs.get(3));
			waitSegs.add(segs.get(7));
			waitSegs.add(segs.get(6));
			
			length = waitSegs.size();
			for(int j = 1;j<=length;j++){
				TaskSeg seg = waitSegs.poll();
				System.out.println("再次乱序后，第"+j+"个分段："+seg.getSegs()+",优先级为："+seg.getPriority());
			}
			System.out.println("-----------------------------------\n");
		} catch (Exception e) {
			e.printStackTrace();
		}

 测试结果：

------------------------------------------------------------------
第1个分段：1-10
第2个分段：11-20
第3个分段：21-30
第4个分段：31-40
第5个分段：41-50
第6个分段：51-60
第7个分段：61-70
第8个分段：71-80
第9个分段：81-90
第10个分段：91-100
------------------------------------------------------------------

修改优先级后，第1个分段：1-10,优先级为：3
修改优先级后，第2个分段：91-100,优先级为：3
修改优先级后，第3个分段：11-20,优先级为：4
修改优先级后，第4个分段：21-30,优先级为：5
修改优先级后，第5个分段：31-40,优先级为：6
修改优先级后，第6个分段：41-50,优先级为：7
修改优先级后，第7个分段：51-60,优先级为：8
修改优先级后，第8个分段：61-70,优先级为：9
修改优先级后，第9个分段：71-80,优先级为：10
修改优先级后，第10个分段：81-90,优先级为：11
------------------------------------------------------------------

再次乱序后，第1个分段：1-10,优先级为：3
再次乱序后，第2个分段：91-100,优先级为：3
再次乱序后，第3个分段：11-20,优先级为：4
再次乱序后，第4个分段：21-30,优先级为：5
再次乱序后，第5个分段：31-40,优先级为：6
再次乱序后，第6个分段：41-50,优先级为：7
再次乱序后，第7个分段：51-60,优先级为：8
再次乱序后，第8个分段：61-70,优先级为：9
再次乱序后，第9个分段：71-80,优先级为：10
再次乱序后，第10个分段：81-90,优先级为：11
------------------------------------------------------------------

解释：
从中可以看到，插入新元素后，队列自动根据其优先级大小将其放入一个位置，从而保证队列中的顺序。由于时间问题，今天到此为止。

Author：肖波

Date：2009-7-18