并发编程复习(八):队列相关
发布日期:2021-11-13 10:21:45 浏览次数:2 分类:技术文章

本文共 5224 字,大约阅读时间需要 17 分钟。

package cn.lh.queue;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.Queue;import java.util.concurrent.*;/** * @Author Lee_Hoo * @DATE Created in 2017/9/22 * @Description: ConcurrentLinkedQueue是一个适用于高并发场景下的并发队列,非阻塞,通过无锁方式,实现高并发状态下的高性能,通常它 * 的性能高于BlockingQueue, * 它是一个基于链接节点的无界线程安全队列,先进先出。 * 主要方法:add()和offer()都是加入元素方法,在ConcurrentLinkedQueue中没有区别 *
  poll()和peek()都是去元素,区别是前者会删除元素,后者不会 *
  BlockingQueue:阻塞队列,有五个实现类 *
ArrayBlockingQueue:内部维护定长数组,没有实现读写分离,生产和消费不能完全并行,可以指定先进先出或者先进后出, *
  也叫有界队列。 *
LinkeedBlockingQueue:基于链表的阻塞队列,采用读写分离,从而实现生产和消费完全的并行,是一个无界队列。 *
SynchronousQueue:没有缓冲的队列,生产出的数据会直接被消费者获得被消费 */public class MyQueue {
public static void main(String[] args) throws InterruptedException {
//高性能的无界无阻赛队列:ConcurrentLinkedQueue
Queue q = new ConcurrentLinkedQueue();
q.add("a");
q.offer("b");
q.add("v");
q.add("d");
System.out.println(q.peek());
System.out.println(q.size());
System.out.println(q.poll());
System.out.println(q.size());
//之所以有界,在于构造时就要指定大小
Queue q1 = new ArrayBlockingQueue(5);
//可以有界也可以无界
//LinkedBlockingQueue q2 = new LinkedBlockingQueue<>();
LinkedBlockingQueue q3 = new LinkedBlockingQueue<>(5);
q3.offer("a");
q3.offer("b");
q3.offer("d");
q3.offer("c");
q3.offer("e");
List list = new ArrayList<>();
q3.drainTo(list,3);
System.out.println(list.size());
//该队列不能添加元素,立即生产立即处理,没有数据缓存,可以这样来理解:生产者和消费者互相等待对方,握手,然后一起离开。
   /* SynchronousQueue ss = new SynchronousQueue<>();
//ss.add("a");//会报错,如果没有线程去take会报错
try {
ss.put(true);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
System.out.println("----------------------------");
//PriorityBlockingQueue:基于优先级的阻塞队列,传入的对象必须实现Comparable接口,内部控制线程同步采用的是公平锁,无界队列
//比较产生的结果如果是负数,那么他的优先级就高
PriorityBlockingQueue  pb = new PriorityBlockingQueue<>();
Task t1 = new Task(1,"张三");
Task t2 = new Task(3,"李四");
Task t3 = new Task(2,"王五");
pb.add(t1);
pb.add(t2);
pb.add(t3);
//排序情况:[Task{id=1, name='张三'}, Task{id=3, name='李四'}, Task{id=2, name='王五'}]
System.out.println(pb);//其实内部存储最先的情况是无序的,没有进行比较排序
//System.out.println(pb.take());//只有当调用take方法只会内部才会进行排序
//System.out.println(pb.remove());//排序
System.out.println(pb.peek());//不排序
//[Task{id=2, name='王五'}, Task{id=3, name='李四'}],进行了比较排序
System.out.println(pb);
}}

Task类:

package cn.lh.queue;import org.jetbrains.annotations.NotNull;/** * @Author Lee_Hoo * @DATE Created in 2017/9/22 * @Description: */public class Task implements Comparable
   
    {
    
private int id;
private String name;
public Task(int id, String name) {
this.id = id;
this.name = name;
}
public Task() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(@NotNull Task task) {
return this.id>task.id?1:(this.id
}
@Override
public String toString() {
return "Task{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}}

网吧场景详解DelayQueue队列:

网吧类:

package cn.lh.queue;import java.util.concurrent.DelayQueue;/** * @Author Lee_Hoo * @DATE Created in 2017/9/22 * @Description: */public class WangBa implements Runnable{
private DelayQueue  queue = new DelayQueue<>();
public boolean yingye = true;
public void shangji(String name,String id,int money){
WangMing wm = new WangMing(id,name,1000*money+System.currentTimeMillis());
System.out.println("网民"+name+"身份证"+id+"交钱"+money+"块"+"开始上机");
this.queue.add(wm);
}
public  void xiaji(WangMing wm){
System.out.println("网名"+wm.getName()+"身份证"+wm.getId()+"下机");
}
@Override
public void run() {
try {
while (yingye){
WangMing man = queue.take();
xiaji(man);
}
}catch (Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
System.out.println("开始营业");
WangBa wb = new WangBa();
Thread shangwang = new Thread(wb);
shangwang.start();
wb.shangji("张三","123",1);
wb.shangji("李四","555",10);
wb.shangji("王五","789",5);
}catch (Exception e){
e.printStackTrace();
}
}}

网民类:

package cn.lh.queue;import org.jetbrains.annotations.NotNull;import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;/** * @Author Lee_Hoo * @DATE Created in 2017/9/22 * @Description: */public class WangMing implements Delayed {
private String id;
private String name;
private long endTime;
private TimeUnit timeUnit = TimeUnit.SECONDS;
public WangMing(String id, String name, long endTime) {
this.id = id;
this.name = name;
this.endTime = endTime;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getEndTime() {
return endTime;
}
public void setEndTime(long endTime) {
this.endTime = endTime;
}
@Override
public long getDelay(@NotNull TimeUnit unit) {
return endTime-System.currentTimeMillis();
}
@Override
public int compareTo(@NotNull Delayed o) {
WangMing w = (WangMing) o;
return this.getDelay(this.timeUnit)-w.getDelay(this.timeUnit)>0?1:0;
}}


转载地址:https://blog.csdn.net/Lee_Ho_/article/details/78063497 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:并发编程复习(九):Future模式
下一篇:并发编程复习(七):并发类容器ConcurrentHashMap&CopyOnWrite

发表评论

最新留言

逛到本站,mark一下
[***.200.74.241]2022年05月27日 16时19分38秒

关于作者

    喝酒易醉,品茶养心,人生如梦,品茶悟道,何以解忧?唯有杜康!
-- 愿君每日到此一游!

最新文章