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