JDK1.5 Queue
编程技术 / houtizong 发布于 3年前 108
JDK1.5 Queue
LinkedList：
LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：
List list = Collections.synchronizedList(new LinkedList(...));
将指定元素追加到列表的结尾有add、offer两个方法，区别是offer是接口 Queue<E>中的，add是接口 Collection<E> 中的。offer使用可能有插入限制（例如容量限定）的队列时，offer方法通常要优于 Collection.add(E) 方法，因为add只能通过抛出异常使插入元素失败。而offer方法的返回值是：如果可以向此队列添加元素，则返回 true；否则返回 false。
找到并移除列表的头（第一个元素）有poll、remove两个方法，区别是poll是接口 Queue<E>中的，remove是接口 Queue<E>中的。如果队列为空，poll返回null，而remove抛出NoSuchElementException。
找到但不移除列表的头（第一个元素）是peek方法
实例：
package com.bijian.thread;import java.util.LinkedList;import java.util.Queue;public class UseLinkedList {public static void main(String[] args) {Queue<String> queue = new LinkedList<String>();queue.offer("Hello");queue.offer("World!");queue.offer("你好！");System.out.println(queue.size());String str;while ((str = queue.poll()) != null) {System.out.println(str);}System.out.println();System.out.println(queue.size());}} 运行结果：
3HelloWorld!你好！0
ArrayBlockingQueue：
一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部 是在队列中存在时间最长的元素。队列的尾部 是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列检索操作则是从队列头部开始获得元素。
ArrayBlockingQueue的常用方法：
put：将指定的元素添加到此队列的尾部，如果必要，将等待可用的空间。
take：检索并移除此队列的头部，如果此队列不存在任何元素，则一直等待。
offer：将指定的元素插入到此队列的尾部（如果可能），如果此队列已满，则立即返回。
poll：检索并移除此队列的头，如果此队列为空，则返回null。
说明：put、offer都是向队列中添加元素，take、poll都是从队列中移除元素。put和take对应一组，是阻塞式的；offer、poll对应一组，是非阻塞式的。
实例：
package com.bijian.thread.blockqueue;import java.util.concurrent.BlockingQueue;public class Producer implements Runnable {private final BlockingQueue<Character> queue;Producer(BlockingQueue<Character> q) {queue = q;}public void run() {try {for (int i = 0; i < 10; i++) {queue.put(produce());System.out.println("生产后：" + queue.peek());}} catch (Exception e) {e.printStackTrace();}}Character produce() {char c = (char) (Math.random() * 26 + 'A');System.out.println("生产前：" + c);return c;}}
package com.bijian.thread.blockqueue;import java.util.concurrent.BlockingQueue;public class Consumer implements Runnable {private String name;private final BlockingQueue<Character> queue;public Consumer(String name, BlockingQueue<Character> q) {this.name = name;this.queue = q;}@Overridepublic void run() {try {while(true) {consume(queue.take());}} catch(InterruptedException e) {e.printStackTrace();}}public void consume(Character c) {System.out.println("[" + name + "]消费: " + c);}}
package com.bijian.thread.blockqueue;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;public class Main {/** * @param args */public static void main(String[] args) {BlockingQueue q = new ArrayBlockingQueue(10);Producer p = new Producer(q);Consumer c1 = new Consumer("tom", q);Consumer c2 = new Consumer("jacky", q);new Thread(c1).start();new Thread(c2).start();new Thread(p).start();}} 运行结果（打印结束后程序一直未结束，但也未输出，处于阻塞状态）：
生产前：L生产后：L生产前：Q[tom]消费: L[jacky]消费: Q生产后：Q生产前：G生产后：G[tom]消费: G生产前：O生产后：O[jacky]消费: O生产前：M生产后：M[tom]消费: M生产前：I生产后：I[jacky]消费: I生产前：B生产后：B生产前：Q[tom]消费: B[jacky]消费: Q生产后：Q生产前：D生产后：D[tom]消费: D生产前：A生产后：A[jacky]消费: A
实例2：
package com.bijian.thread.blockqueue;import java.util.concurrent.BlockingQueue;public class Producer implements Runnable {private final BlockingQueue<Character> queue;Producer(BlockingQueue<Character> q) {queue = q;}public void run() {try {for (int i = 0; i < 10; i++) {queue.offer(produce());//System.out.println("生产后：" + queue.peek());}} catch (Exception e) {e.printStackTrace();}}Character produce() {char c = (char) (Math.random() * 26 + 'A');System.out.println("生产前：" + c);return c;}}
package com.bijian.thread.blockqueue;import java.util.concurrent.BlockingQueue;public class Consumer implements Runnable {private String name;private final BlockingQueue<Character> queue;public Consumer(String name, BlockingQueue<Character> q) {this.name = name;this.queue = q;}@Overridepublic void run() {while(true) {consume(queue.poll());try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}public void consume(Character c) {System.out.println("[" + name + "]消费: " + c);}}
package com.bijian.thread.blockqueue;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;public class Main {/** * @param args */public static void main(String[] args) {BlockingQueue q = new ArrayBlockingQueue(10);Producer p = new Producer(q);Consumer c1 = new Consumer("tom", q);Consumer c2 = new Consumer("jacky", q);new Thread(p).start();new Thread(c1).start();new Thread(c2).start();}}
运行结果（打印结束后程序一直未结束，消费者一直输出null，处于非阻塞状态）：
[tom]消费: null[jacky]消费: null生产前：S生产前：R生产前：N生产前：S生产前：P生产前：U生产前：J生产前：Y生产前：C生产前：H[jacky]消费: S[tom]消费: R[jacky]消费: N[tom]消费: S[tom]消费: P[jacky]消费: U[jacky]消费: J[tom]消费: Y[jacky]消费: C[tom]消费: H[jacky]消费: null[tom]消费: null[tom]消费: null[jacky]消费: null……
DelayQueue：
Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满。此队列不允许使用 null 元素。
DelayQueue的常用方法：
add：将指定元素添加到此队列中。
offer：将指定元素插入到此延迟队列中。
put：将指定元素添加到此延迟队列中。由于该队列是无界的，所以此方法永远不会阻塞。
take：检索并移除此队列的头部，如果此队列不存在未到期延迟的元素，则等待它。
poll：检索并移除此队列的头部，如果此队列不存在未到期延迟的元素，则返回null。
remove：从此队列中移除指定元素的单个实例（如果存在）。
drainTo：移除此队列中所有可用的元素，并将它们添加到给定 collection 中。
实例：
package com.bijian.thread.blockqueue.delayqueue;import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;public class NanoDelay implements Delayed {private String name;private long targetTime;public NanoDelay(String name, long targetTime) {super();this.name = name;this.targetTime = TimeUnit.NANOSECONDS.convert(targetTime, TimeUnit.NANOSECONDS);}@Overridepublic int compareTo(Delayed o) {NanoDelay that = (NanoDelay)o;return targetTime > that.targetTime?1:(targetTime < that.targetTime?-1:0);}@Overridepublic long getDelay(TimeUnit unit) {return unit.convert(targetTime, unit.NANOSECONDS);}@Overridepublic String toString() {StringBuilder builder = new StringBuilder();builder.append("NanoDelay [name=");builder.append(name);builder.append(", targetTime=");builder.append(targetTime);builder.append("]");return builder.toString();}}
package com.bijian.thread.blockqueue.delayqueue;import java.util.Random;import java.util.concurrent.DelayQueue;public class Main {public static void main(String args[]) {Random random = new Random();DelayQueue<NanoDelay> queue = new DelayQueue<NanoDelay>();for (int i = 0; i < 5; i++) {queue.add(new NanoDelay("T" + i, random.nextInt(5)));}System.out.println("start..");System.out.println(queue.size());for(int i = 0; i < 5; i++) {try {NanoDelay delay = queue.take();System.out.println(delay);} catch (InterruptedException e) {e.printStackTrace();}}}} 运行结果（打印结束后程序一直未结束，但也未输出，处于阻塞状态）：
start..5NanoDelay [name=T1, targetTime=0]
请勿发布不友善或者负能量的内容。与人为善，比聪明更重要！
技术博客集 - 网站简介：
前后端技术：
后端基于Hyperf2.1框架开发,前端使用Bootstrap可视化布局系统生成
网站主要作用：
1.编程技术分享及讨论交流，内置聊天系统;
2.测试交流框架问题，比如：Hyperf、Laravel、TP、beego;
3.本站数据是基于大数据采集等爬虫技术为基础助力分享知识，如有侵权请发邮件到站长邮箱，站长会尽快处理;
4.站长邮箱：[email protected];
文章归档
文章标签
友情链接
