1.并发队列的介绍
在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。
2.ConcurrentLinkedQueue
ConcurrentLinkedQueue：是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的，该队列不允许null元素。
ConcurrentLinkedQueue重要方法：
add()和offer()都是加入元素的方法在ConcurrentLinkedQueue中,这两个方法没有任何区别）
poll()和peek()都是取头元素节点，区别在于前者会删除元素，后者不会
import java.util.concurrent.ConcurrentLinkedQueue;
public class Demo {
public static void main(String[] args) throws Exception {
//高性能无阻塞无界队列：ConcurrentLinkedQueue
ConcurrentLinkedQueue<String> q = new ConcurrentLinkedQueue<String>();
q.offer("a");
q.offer("b");
q.offer("c");
q.offer("d");
q.add("e");
System.out.println(q.poll()); //从头部取出元素，并从队列里删除
System.out.println(q.size());
System.out.println(q.peek());
System.out.println(q.size());
}
}执行上述代码，其输出结果为：
a
4
b
43.BlockingQueue 接口
3.1 ArrayBlockingQueue
ArrayBlockingQueue：基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，其内部没实现读写分离，也就意味着生产和消费不能完全并行，长度是需要定义的，可以指定先进先出或者先进后出，也叫“有界队列”，在很多场合非常适合使用。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
public class Demo {
public static void main(String[] args) throws Exception {
ArrayBlockingQueue<String> array = new ArrayBlockingQueue<String>(5);
array.put("a");
array.put("b");
array.add("c");
array.add("d");
array.add("e");
System.out.println(array.offer("a", 3, TimeUnit.SECONDS));
}
}上述代码为定义一个长度为5的有界阻塞队列，往队列里面添加5个元素：a、b、c、d、e，然后在使用 array.offer("a", 3, TimeUnit.SECONDS) 方法，如果3秒钟以后往队列里面添加元素a成功的话，则返回true，不成功的话则返回false。
3.2 LinkedBlockingQueue
LinkedBlockingQueue：基于链表的阻塞队列，同ArrayBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），LinkedBlockingQueue之所以能够高效的处理并发数据，是因为其内部实现采用分离锁（读写分离两个锁），从而实现生产者和消费者操作的完全并行运行，它是一个无界队列。
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
public class Demo {
public static void main(String[] args) throws Exception {
//阻塞队列
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<>();
q.offer("a");
q.offer("b");
q.offer("c");
q.offer("d");
q.offer("e");
q.add("f");
for (Iterator iterator = q.iterator(); iterator.hasNext();) {
String string = (String) iterator.next();
System.out.println(string);
}
}
}执行上述代码，其输出结果为：
a
b
c
d
e
fLinkedBlockingQueue在创建的时候可以指定长度，也可以不指定长度
其中LinkedBlockingQueue中有一个drainTo方法，该方法表示从队列中批量取出元素放到集合中
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
public class Demo {
public static void main(String[] args) throws Exception {
//阻塞队列
LinkedBlockingQueue<String> q = new LinkedBlockingQueue<>();
q.offer("a");
q.offer("b");
q.offer("c");
q.offer("d");
q.offer("e");
q.add("f");
List<String> list = new ArrayList<>();
System.out.println(q.drainTo(list, 3));
for (String string : list) {
System.out.println(string);
}
}
}
执行上述代码，其输出结果为：
3
a
b
c3.3 SynchronousQueue
SynchronousQueue：一种没有缓冲的队列，生产者产生的数据直接会被消费者获取并消费
import java.util.concurrent.SynchronousQueue;
public class Demo {
public static void main(String[] args){
final SynchronousQueue<String> q = new SynchronousQueue<String>();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(q.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
q.add("abc");
}
});
t2.start();
}
}
执行上述代码，其输出结果为：
abc3.4 PriorityBlockingQueue
PriorityBlockingQueue：基于优先级的阻塞队列(优先级的判断通过构造函数传入的Compator对象来决定，也就是说传入队列的对象必须实现Comparable接口并重写里面的compareTo方法)，在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁，它也是一个无界的队列。
import lombok.Data;
@Data
public class Task implements Comparable<Task>{
private int id ;
private String name;
@Override
public int compareTo(Task task) {
return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);
}
public String toString(){
return this.id + "," + this.name;
}
}import java.util.concurrent.PriorityBlockingQueue;
public class Demo {
public static void main(String[] args) throws InterruptedException{
PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();
Task t1 = new Task();
t1.setId(3);
t1.setName("张三");
Task t2 = new Task();
t2.setId(4);
t2.setName("李四");
Task t3 = new Task();
t3.setId(1);
t3.setName("王五");
queue.add(t1);
queue.add(t2);
queue.add(t3);
System.out.println("队列：" + queue);
System.out.println(queue.take().toString());
System.out.println(queue.take().toString());
System.out.println(queue.take().toString());
}
}执行上述代码，其输出结果为：
队列：[1,王五, 4,李四, 3,张三]
1,王五
3,张三
4,李四特别说明：优先级阻塞队列注意指的是队列里面的元素在被取出（调用take）时具有优先级
3.5 DelayQueue
DelayQueue：带有延迟时间的Queue，其中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue中的元素必须实现Delayed接口并重写里面的getDelay方法和compareTo方法，DelayQueue是一个没有大小限制的队列，应用场景很多，比如对缓存超时的数据进行移除、任务超时处理、空虚连接的关闭等等。
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
@Getter
@AllArgsConstructor
public class Wangmin implements Delayed {
private String name;
//身份证
private String id;
//截止时间
private long endTime;
/**
* 用来判断是否到了截止时间
*/
@Override
public long getDelay(TimeUnit unit) {
return endTime - System.currentTimeMillis();
}
/**
* 相互比较排序
*/
@Override
public int compareTo(Delayed delayed) {
Wangmin w = (Wangmin)delayed;
return this.getDelay(TimeUnit.SECONDS) - w.getDelay(TimeUnit.SECONDS) > 0 ? 1:0;
}
} import java.util.concurrent.DelayQueue;
public class WangBa implements Runnable {
private DelayQueue<Wangmin> queue = new DelayQueue<>();
public boolean yinye = true;
public void shangji(String name, String id, int money) {
Wangmin man = new Wangmin(name, id, 1000 * money + System.currentTimeMillis());
System.out.println("网名" + man.getName() + " 身份证" + man.getId() + "交钱" + money + "块,开始上机...");
this.queue.add(man);
}
public void xiaji(Wangmin man) {
System.out.println("网名" + man.getName() + " 身份证" + man.getId() + "时间到下机...");
}
@Override
public void run() {
while (yinye) {
try {
Wangmin man = queue.take();
xiaji(man);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String args[]) {
try {
System.out.println("网吧开始营业");
WangBa siyu = new WangBa();
Thread t1 = new Thread(siyu);
t1.start();
siyu.shangji("路人甲", "123", 1);
siyu.shangji("路人乙", "234", 10);
siyu.shangji("路人丙", "345", 5);
} catch (Exception e) {
e.printStackTrace();
}
}
} 执行上述代码，其输出结果为：
网吧开始营业
网名路人甲 身份证123交钱1块,开始上机...
网名路人乙 身份证234交钱10块,开始上机...
网名路人丙 身份证345交钱5块,开始上机...
网名路人甲 身份证123时间到下机...
网名路人丙 身份证345时间到下机...
网名路人乙 身份证234时间到下机...
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
