Java-Queue总结
1. ConcurrentLinkedQueue
基础链表同步队列。
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
//底层链表实现 队列，先进先出
public class Test_03_ConcurrentLinkedQueue {
public static void main(String[] args) {
Queue<String> queue = new ConcurrentLinkedQueue<>();
for (int i = 0; i < 10; i++) {
queue.offer("value" + i);
}
System.out.println(queue);
System.out.println(queue.size());
//peek() 查看queue中的首数据
System.out.println(queue.peek());
System.out.println(queue.size());
//poll()->获取queue首数据
System.out.println(queue.poll());
System.out.println(queue.size());
}
}
LinkedBlockingQueue
阻塞队列，队列容量不足自动阻塞，队列容量为 0 自动阻塞
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
/** 并发容器 - LinkedBlockingQueue
* 阻塞容器。
* put & take - 自动阻塞。
* put自动阻塞， 队列容量满后，自动阻塞
* take自动阻塞方法， 队列容量为0后，自动阻塞。
*/
public class Test_04_LinkBlockingQueue {
final BlockingQueue<String> queue = new LinkedBlockingQueue<>();
final Random r = new Random();
public static void main(String[] args) {
final Test_04_LinkBlockingQueue t = new Test_04_LinkBlockingQueue();
new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
t.queue.put("value"+t.r.nextInt(1000));
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "producer").start();
for(int i = 0; i < 3; i++){
new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
System.out.println(Thread.currentThread().getName() +
" - " + t.queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "consumer"+i).start();
}
}
}
ArrayBlockingQueue
底层数组实现的有界队列。自动阻塞。根据调用 API（add/put/offer）不同，有不同特 性。 当容量不足的时候，有阻塞能力。 add 方法在容量不足的时候，抛出异常。 put 方法在容量不足的时候，阻塞等待。 offer 方法， 单参数 offer 方法，不阻塞。容量不足的时候，返回 false。当前新增数据操作放弃。 三参数 offer 方法（offer(value,times,timeunit)），容量不足的时候，阻塞 times 时长（单 位为 timeunit），如果在阻塞时长内，有容量空闲，新增数据返回 true。如果阻塞时长范围 内，无容量空闲，放弃新增数据，返回 false
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class Test_05_ArrayBlockingQueue {
//当容量不足的时候，有阻塞能力
//add 方法在容量不足的时候，抛出异常
//put 方法在容量不如的时候，阻塞等待
//offer 方法，单参数，容量不足的时候，返回false。当前新增数据操作放弃
//offer 三参数，容量不足的时候，阻塞times时长（单位为timeunit）,如果在阻塞时长内,
//有容量空闲，新增数据返回true，如果阻塞时长范围内，无容量空闲，放弃新增数据，返回false
final BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
public static void main(String[] args) {
final Test_05_ArrayBlockingQueue t = new Test_05_ArrayBlockingQueue();
for (int i = 0; i < 5; i++) {
// System.out.println("add method : " + t.queue.add("value"+i));
/*
* try { t.queue.put("put"+i); } catch (InterruptedException e) {
* e.printStackTrace(); } System.out.println("put method : " + i);
*/
// System.out.println("offer method : " + t.queue.offer("value"+i));
try {
System.out.println("offer method : " + t.queue.offer("value" + i, 1, TimeUnit.SECONDS));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(t.queue);
}
}
DelayQueue
延时队列。根据比较机制，实现自定义处理顺序的队列。常用于定时任务。 如：定时关机
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
//有顺序有时间的排序
//延时队列，根据比较机制，实现自定义处理顺序的队列。常用于定时任务
public class Test_06_DelayQueue {
static BlockingQueue<MyTask_06> queue = new DelayQueue<>();
public static void main(String[] args) throws InterruptedException {
long value = System.currentTimeMillis();
MyTask_06 task1 = new MyTask_06(value + 2000);
MyTask_06 task2 = new MyTask_06(value + 1000);
MyTask_06 task3 = new MyTask_06(value + 3000);
MyTask_06 task4 = new MyTask_06(value + 2500);
MyTask_06 task5 = new MyTask_06(value + 1500);
queue.put(task1);
queue.put(task2);
queue.put(task3);
queue.put(task4);
queue.put(task5);
System.out.println(queue);
System.out.println(value);
for (int i = 0; i < 5; i++) {
System.out.println(queue.take());
}
}
}
class MyTask_06 implements Delayed {
private long compareValue;
public MyTask_06(long compareValue) {
this.compareValue = compareValue;
}
/**
* 比较大小。自动实现升序 建议和getDelay方法配合完成。
* 如果在DelayQueue是需要按时间完成的计划任务，必须配合getDelay方法完成。
*/
@Override
public int compareTo(Delayed o) {
return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
}
/**
* 获取计划时长的方法。 根据参数TimeUnit来决定，如何返回结果值。
*/
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(compareValue - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
@Override
public String toString() {
return "Task compare value is : " + this.compareValue;
}
}
LinkedTransferQueue
转移队列，使用 transfer 方法，实现数据的即时处理。没有消费者，就阻塞
/**
* 并发容器 - LinkedTransferQueue
* 转移队列
* add - 队列会保存数据，不做阻塞等待。
* transfer - 是TransferQueue的特有方法。必须有消费者（take()方法的调用者）。
* 如果没有任意线程消费数据，transfer方法阻塞。一般用于处理即时消息。
*/
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TransferQueue;
public class Test_07_TransferQueue {
TransferQueue<String> queue = new LinkedTransferQueue<>();
public static void main(String[] args) {
final Test_07_TransferQueue t = new Test_07_TransferQueue();
/*
* new Thread(new Runnable() {
*
* @Override public void run() { try {
* System.out.println(Thread.currentThread().getName() +
* " thread begin " );
* System.out.println(Thread.currentThread().getName() + " - " +
* t.queue.take()); } catch (InterruptedException e) {
* e.printStackTrace(); } } }, "output thread").start();
*
* try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {
* e.printStackTrace(); }
*
* try { t.queue.transfer("test string"); } catch (InterruptedException
* e) { e.printStackTrace(); }
*/
new Thread(new Runnable() {
@Override
public void run() {
try {
t.queue.transfer("test string");
// t.queue.add("test string");
System.out.println("add ok");
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " thread begin ");
System.out.println(Thread.currentThread().getName() + " - " + t.queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "output thread").start();
}
}
SynchronusQueue
同步队列，是一个容量为 0 的队列。是一个特殊的 TransferQueue。 必须现有消费线程等待，才能使用的队列。 add 方法，无阻塞。若没有消费线程阻塞等待数据，则抛出异常。 put 方法，有阻塞。若没有消费线程阻塞等待数据，则阻塞
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
public class Test_08_SynchronusQueue {
BlockingQueue<String> queue = new SynchronousQueue<>();
public static void main(String[] args) {
final Test_08_SynchronusQueue t = new Test_08_SynchronusQueue();
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " thread begin " );
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " - " + t.queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "output thread").start();
/*try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
// t.queue.add("test add");
try {
t.queue.put("test put");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " queue size : " + t.queue.size());
}
}
