1. DelayQueue延迟阻塞队列。
该队列主要作用是延迟添加元素,mQueue,put(Delay),当item未达到timeout的界限时,take获取元素时候会发生阻塞,一直等到元素item达到timeout延迟发生。
DelayQueue应用场景
订单超时
session绘话超时
支付超时
xxx超时
2.DelayQueue实例
由于添加到DelayQueue的item延迟10s,所以调用take方法时候需要等待10秒才可以获取到,否则一直block阻塞状态。
DelayQueue<Task> mQueue = new DelayQueue<Task>();
//添加一个task item到DelayQueue
mQueue.put(new Task(10*1000,"data"));
//直接获取
try {
System.out.println("Queue take data waiting for...");
Task task = mQueue.take();
String strData = task.getData();
System.out.println("Queue take data succ -> " + strData);
} catch (InterruptedException e) {
e.printStackTrace();
}
public class Task implements Delayed,Runnable{
private long delay;
private String data;
public String getData(){
return this.data;
}
public long getDelay(){
return this.delay;
}
public Task(long delay,String data){
this.delay = delay + Calendar.getInstance().getTimeInMillis();
this.data = data;
}
@Override
public int compareTo(Delayed o) {
// TODO Auto-generated method stub
return 0;
}
@Override
public long getDelay(TimeUnit unit) {
// TODO Auto-generated method stub
long r = delay - Calendar.getInstance().getTimeInMillis();
return r;
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("[Task]" + " run...");
}
}
3.PriorityBlockQueue优先级阻塞队列
优先级阻塞队列,就是添加到该队列的Item,需要权值顺序处理。权值顺序处理是通过comparator接口来实现。
特点:priorityBlockQueue是无界队列,put(capacity)无需阻塞住
PriorityBlockQueue底层是数组Array实现,默认大小是11,扩容策略按照原来大小1.5倍大小或者2x+2长度扩容源码如下
JDK源码
/**
* Inserts the specified element into this priority queue. As the queue is
* unbounded this method will never block.
*
* @param e the element to add
* @throws ClassCastException if the specified element cannot be compared
* with elements currently in the priority queue according to the
* priority queue's ordering
* @throws NullPointerException if the specified element is null
*/
public void put(E e) {
offer(e); // never need to block
}
//扩容策略
/**
* Inserts the specified element into this priority queue.
*
* @return {@code true} (as specified by {@link Queue#offer})
* @throws ClassCastException if the specified element cannot be
* compared with elements currently in this priority queue
* according to the priority queue's ordering
* @throws NullPointerException if the specified element is null
*/
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
modCount++;
int i = size;
if (i >= queue.length)
grow(i + 1);
size = i + 1;
if (i == 0)
queue[0] = e;
else
siftUp(i, e);
return true;
}
/**
* Increases the capacity of the array.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
int oldCapacity = queue.length;
// Double size if small; else grow by 50%
int newCapacity = ((oldCapacity < 64)?
((oldCapacity + 1) * 2):
((oldCapacity / 2) * 3));
if (newCapacity < 0) // overflow
newCapacity = Integer.MAX_VALUE;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
queue = Arrays.copyOf(queue, newCapacity);
}
4.PriorityBlockQueue实例
private PriorityBlockingQueue<Integer> queue;
this.queue = new PriorityBlockingQueue<Integer>(12,mComparator);
this.queue.add(1);
this.queue.add(10);
this.queue.add(20);
this.queue.add(30);
Thread thread = new Thread(){
@Override
public void run() {
while(true){
try {
System.out.println("get data waiting...");
Integer data = queue.take();
System.out.println("get data is -> " + data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
thread.start();
private Comparator<Integer> mComparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
// TODO Auto-generated method stub
return o2-o1; //权值是逆序处理,降序排列
}
};
按照优先级降序处理,所以输出结果也是按照降序顺序
输出结果:
get data waiting...
get data is -> 30
get data waiting...
get data is -> 20
get data waiting...
get data is -> 10
get data waiting...
get data is -> 1
get data waiting...