常见五大队列使用教程

最新推荐文章于 2024-08-25 17:35:10 发布
最新推荐文章于 2024-08-25 17:35:10 发布
阅读量845 收藏 1
点赞数
分类专栏： 新手入门教程 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tttalk/article/details/121947982
版权

1.常用五大队列使用教程
啥都不说了，直接上代码，里面注释很详细

package com.example.springb_web.utils.Queue;


import java.text.DateFormat;
import java.time.Duration;
import java.util.Comparator;
import java.util.Date;
import java.util.PriorityQueue;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

//队列分有界/无界队列，阻塞/非阻塞队列
// 阻塞队列：含BlockingQueue 关键字，当队列满之后如果还有新元素通过put入列时， 会阻塞队列
// 非阻塞队列：不含put和take方法，队列满后在入列会直接返回错误
//普通队列中常用方法：
// 添加元素：offer--队列满插入返回false，反之true;add--对offer的封装，队列满抛异常；put--队列满则阻塞
// 删除元素：remove--删除队头元素；poll--删除并返回队头元素，队列为空返回null；take--删除并返回队头元素，队列为空阻塞
// 获取元素:上面的poll和take;peek--返回队头元素，不会删除;element--peek的封装，元素存在则取出，不存在抛出异常
// 常用搭配:offer和poll(常用，效率不错，不报错);put和take(阻塞);add和remove
public class QueueTest {
    public static void main(String[] args) throws Exception {
        //普通队列
        LinkedBlockingQueue normalQueue = new LinkedBlockingQueue();
        System.out.println(normalQueue.poll());
        //normalQueue.offer(null);
        normalQueue.offer("normal1");
        normalQueue.offer("normal2");
        while (!normalQueue.isEmpty()) {
            //先进先出
            System.out.println(normalQueue.poll());
        }

        //双端队列（Deque）：双端队列是指队列的头部和尾部都可以同时入队和出队的数据结构
        LinkedBlockingDeque deque = new LinkedBlockingDeque();
        deque.offer("deque1");
        deque.offerFirst("dequeFirst1");
        deque.offerFirst("dequeFirst2");
        deque.offerLast("dequeLast");
        while (!deque.isEmpty()) {
            //先进先出
            System.out.println(deque.poll());
        }

        //优先队列（PriorityQueue）：优先队列是一种特殊的队列，它并不是先进先出的，而是优先级高的元素先出队。
        //优先队列根据二叉堆实现的。二叉堆分为两种类型：一种是最大堆一种是最小堆。在最大堆中，任意一个父节点的值都大于等于它左右子节点的值。
        /*Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o, Object t1) {
                return 0;
            }
        };*/
        Comparator comparator = (Object obj1, Object obj2) -> {
            return Integer.valueOf(String.valueOf(obj1)) - Integer.valueOf(String.valueOf(obj2));
        };
        PriorityQueue priorityQueue = new PriorityQueue(10, comparator);
        priorityQueue.offer("9");
        priorityQueue.offer("8");
        priorityQueue.offer("37");
        priorityQueue.offer("13");
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }

        //延迟队列，当入队的元素到达指定的延迟时间之后方可出队
        DelayQueue delayQueue = new DelayQueue();
        delayQueue.put(new MyDelay("delay1", (long) 3000));
        delayQueue.put(new MyDelay("delay2", (long) 1000));
        System.out.println("delay--begin" + DateFormat.getDateTimeInstance().format(new Date()));
        //这里不能用poll这种方法，因为有延迟的原因，不然会持续输出很多null
        while (!delayQueue.isEmpty()) {
            System.out.println("delay--" + DateFormat.getDateTimeInstance().format(new Date()) + " " + ((MyDelay) delayQueue.take()).getMsg());
        }
        System.out.println("delay--end" + DateFormat.getDateTimeInstance().format(new Date()));


        //其他队列:如特殊的队列 SynchronousQueue，它的特别之处在于它内部没有容器，每次进行 put() 数据后（添加数据），必须等待另一个线程拿走数据后才可以再次添加数据
        SynchronousQueue synchronousQueue = new SynchronousQueue();
        //入队
        ProducerThread producerThread = new ProducerThread(synchronousQueue);
        Thread thread = new Thread(producerThread);
        thread.start();
        //出队
        new Thread(() -> {
            try {
                //这里不能用isEmpty判断，由于没有容器，synchronousQueue一直为0
                //while (!synchronousQueue.isEmpty()){
                while (true) {
                    //Thread.sleep(1000);
                    System.out.println("take:" + synchronousQueue.take());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        //自定义队列，可以使用数组、链表、list等储存队列
        MyQueue myQueue = new MyQueue(10);
        myQueue.offer("myQueue1");
        myQueue.offer("myQueue2");
        System.out.println(myQueue.peek().item);
        while (!myQueue.isEmpty()){
            System.out.println(myQueue.poll().item);
        }


    }
}
class ProducerThread implements Runnable{

    private SynchronousQueue synchronousQueue;
    private AtomicInteger count = new AtomicInteger();

    public  ProducerThread(SynchronousQueue synchronousQueue){
        this.synchronousQueue = synchronousQueue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            try {
                //这里发现，先进行两次put,第二次put的时会被阻塞，此时唤醒take,在第二次take时被阻塞，此时唤醒第二次put。提供者和消费者是需要组队完成工作，缺少一个将会阻塞线程，直到配对为止
                //查看逻辑，发现put和take都调用的this.transferer.transfer()方法，没有使用aqs，使用了一系列cas保证线程安全问题
                // 公平与非公平模式：
                // 1.公平模式下底层使用的是TransferQueue，是一个先进先出的队列：TransferQueue队列有一个head和tail指针，用于指向当前正在等待匹配的线程节点
                //  ①put1线程put进一条数据后，自旋后休眠，put2同理，此时head为null,tail为put2;
                //  ②take1线程进来，此时take1和put2配对，由于是公平策略(队尾匹配队头出队)，唤醒的是put1,消费put1。然后take2进来匹配put2后消费。
                // 2.非公平模式底层采用了后进先出的TransferStack栈来实现：TransferStack栈中用head指针指向栈顶
                //  ①put1线程put进一条数据后，自旋后休眠，put2同理，此时put2在栈顶,head指向put2,put1在栈底，栈方向为栈底指向栈顶;
                //  ②take1进来与put2匹配，并消费，之后把head指向put1,take2进来将匹配put1后消费。
                synchronized (this.count){
                    System.out.println("put-before:synchronousQueue" + i);
                    synchronousQueue.put("synchronousQueue" + i);
                    System.out.println("put-after:synchronousQueue" + i);
                }
                count.getAndIncrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    };
}

class MyDelay implements Delayed{

    private String msg;
    //延迟时间
    private long delayTime;

    //初始化，传入延时时间
    public MyDelay(String msg,Long delayMills){
        this.msg = msg;
        this.delayTime = System.currentTimeMillis() + delayMills;
    }

    //获取剩余时间,必须重写，delayTime为初始化设置的时间（相当于定时了），出列会在getDelay返回0（当前时间达到设定的时间）的时候
    @Override
    public long getDelay(TimeUnit timeUnit) {
        return timeUnit.convert(Duration.ofMillis(delayTime - System.currentTimeMillis()));
    }

    //队列元素排序依据,谁剩余的延迟时间短，谁在前面。跟谁先入队列无关
    @Override
    public int compareTo(Delayed delayed) {
        if((this.delayTime-System.currentTimeMillis()) > delayed.getDelay(TimeUnit.MILLISECONDS)){
            return 1;

        }else if((this.delayTime-System.currentTimeMillis()) < delayed.getDelay(TimeUnit.MILLISECONDS)){
            return -1;
        }
        return 0;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public long getDelayTime() {
        return delayTime;
    }

    public void setDelayTime(long delayTime) {
        this.delayTime = delayTime;
    }
}

class MyQueue{
    private Node firstNode;
    private Node lastNode;
    private int size;
    private int maxSize;

    //自定义Node链表节点
    static class Node<E> {
        E item; // 当前的值
        Node<E> next; // 下一个节点
        Node(E e) {
            this.item = e;
        }
    }

    //初始化构造函数
    public MyQueue(int maxSize){
        if(maxSize <= 0){
            throw new RuntimeException("最大队列不能为空");
        }
        this.firstNode = this.lastNode = new Node(null);
        this.size = 0;
        this.maxSize = maxSize;

    }

    public boolean isEmpty(){
        return size == 0;
    }
    public void offer(Object e){
        if(maxSize <= size){
            throw new RuntimeException("队列已满");
        }
        //如果为add方法则加上这个判断
       /* if(e == null){
            throw new RuntimeException("元素不能为空");
        }*/
        Node node = new Node(e);
        //这一步是关键，将尾节点的下一节点赋值为当前传入的值（当前节点的next为空代表它为最后一个元素）,并将尾节点重新定义
        lastNode = lastNode.next = node;
        //作用等同如下
        /*lastNode.next = node;
        lastNode = lastNode.next;*/
        size ++;

    }
    public Node poll(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        size -- ;
        //设置首节点并返回原首节点
        return firstNode = firstNode.next;
    }
    //查询队头元素
    public Node peek(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        return firstNode.next;//第几个节点为null
    }
}

输出结果如下：
在这里插入图片描述
2.PriorityQueue的公平与非公平模式介绍：
（1）.公平模式下底层使用的是TransferQueue，是一个先进先出的队列：TransferQueue队列有一个head和tail指针，用于指向当前正在等待匹配的线程节点
①初始化

在这里插入图片描述

②put1线程put进一条数据后，自旋后休眠，put2同理，此时head为null,tail为put2;
在这里插入图片描述

③take1线程进来，此时take1和put2配对，由于是公平策略(队尾匹配队头出队)，唤醒的是put1,消费put1。然后take2进来匹配put2后消费。

（2）非公平模式底层采用了后进先出的TransferStack栈来实现：TransferStack栈中用head指针指向栈顶
①put1线程put进一条数据后，自旋后休眠，put2同理，此时put2在栈顶,head指向put2,put1在栈底，栈方向为栈底指向栈顶;
在这里插入图片描述

②take1进来与put2匹配，并消费，之后把head指向put1,take2进来将匹配put1后消费。

TTTALK
关注
专栏目录
@Async注解的使用教程以及常见的失效场景
黄团团的个人博客
09-12 4204
在Spring当中，被@Async注解标记的方法，称为异步方法，这些方法会在线程当中独立执行，开发人员无需等待它的完成，可以继续其他的业务操作；Spring容器在初始化Bean时，会先判断Bean中是否使用了@Async注解，创建切点，根据切点创建代理，在调用@Async注解标注的方法时，会调用代理，执行切点的Invoke方法，将方法的执行交给线程池进行异步执行。
队列简易教程
冷山不生云
10-28 646
队列(FIFO) 概论 基本概念 只在线性表的一端进行添加元素，在线性表的另一端进行删除元素的数据结构称为队列。这种规则称为 **FIFO（first input first output）**原则。 进入队列的一端称为“队尾”，出队列的一端称为“队头”。 应用场景 根据队列的存储特性，只需要使用数据结构实现一种顺序执行 / 访问的场景可以使用队列。计算机开发中使用队列这种逻辑结构也非常广泛，像...
队列的基本用法
qq_30534935的博客
02-11 2131
转载： https://blog.csdn.net/dy_1748204009/article/details/60592794 https://www.cnblogs.com/yaoyueduzhen/p/4456430.html 一、什么是队列 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。Queue接口与List、Set同一级别，都是继承了Collecti...
数据结构——队列
最新发布
2301_78622258的博客
08-25 644
队列的操作
队列的用法
lowB程序员
09-23 1215
队列本质上是一种特殊的线性表，它是在一端（队首）进行删除操作，而在另外一端（队尾）进行插入操作，它要遵循先进先出的规则。 队首(front) ：允许进行删除的一端称为队首。 队尾(rear) ：允许进行插入的一端称为队尾。 队列有两种数据存储方式：1、顺序存储结构（静态队列，用数组实现，地址是连续的）。2、链式存储结构（动态队列，用动态链表实现，地址是不连续的）。 一、队列的基本操作：
队列的使用详解
2201_75452232的博客
02-28 3514
Java中Queue应用场景详解
队列的使用
weixin_44547668的博客
03-16 461
概述 1)队列是一个有序列表,可以用数组或者链表实现 2)遵循先入先出FIFO得原则 数组模拟队列思路 队列本身是有序列表,若使用数组得结构来存储队列的数据 因为队列的输出输入分别从前后端来处理,因此需要两个变量分别记录前后端的下标,front会随着数据输出而改变,rear会随着数据输入而改变 当我们将数据存入队列时,成为addQueue,处理步骤而两个. 1)将尾指针后移:rear+1,当frontrear[空] 2)尾指针小于队列最大下标maxsize-1,则将数据存入rear所指的数组元素中,否则无法
模板编程实现栈与队列操作教程
描述和标签中涉及到的栈和队列的模板实现，是数据结构课程中常见的教学内容。在实际编程中，使用模板来实现这些基本数据结构可以使代码更加灵活和通用。模板的引入不仅提高了代码的复用率，还能够帮助开发者写出类型...
消息队列MessageQueue简介及RabbitMQ五大模型总结
JunsIr的技术栈
05-11 1940
消息队列MessageQueue简介及RabbitMQ五大模型总结 WHAT IS MQ 消息队列，即MQ，Message Queue。 消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦 AMQP与JMS MQ是消息通信的模型，并不是具体实现。现在实现MQ的有两种主流方式：AMQP、JMS 两者间的区别和联系： JMS是定义了统一的接口，来对消
TensorFlow教程深度解析：队列与线程机制
资源摘要信息: "深度学习框架(TensorFlow)基础教程——第8章：队列与线程" 知识点一：TensorFlow基础知识回顾 TensorFlow是谷歌开发的一个开源深度学习框架，它广泛应用于语音识别、图像识别、自然语言处理等复杂...
队列使用方法详细讲解
galaxyrt的博客
05-23 2154
队列详细讲解 队列是一种先进先出的线性表，它只允许在表的一段进行插入元素，在表的另一端删除元素，先进先出，插入的一端叫做队尾(back），删除的一段叫做对头（front） 队列定义在<queun>头文件中 下面代码是队列成员的函数原型： //-----容量capacity----- bool empty();//测试是否为空队列 size_type size();//返回队列长度 //-----元素存取element access---- front();//返回对头元素 back(
【JAVA】leetcode刷题基础：Queue队列（Queue、PriorityQueue）
AXIMI的博客
04-23 1256
PriorityQueue PriorityQueue保存队列元素的顺序不是它们加入队列的顺序，而是他们的大小（默认poll的顺序是从小到大）。所以使用peek()、poll()函数取出队列中的元素时，不是取出最先存进去的元素而是所有元素中最小的元素。 同时PriorityQueue不允许插入null元素，他存储的元素必须是可以比较的对象，否则要指明比较器。 PriorityQueue实现自定...
数据结构与算法（双端队列）
weixin_62173637的博客
01-14 154
1.接口 ​ package p1.接口; public interface Queue<E> extends Iterable<E> { public void offer(E element); //入队 public E poll(); //出队 public E peek(); //查看队首元素 public boolean isEmpty(); public void clear(); public in
【Java数据结构】使用数组模拟队列
aaa_bbb_ccc_123_456的博客
12-23 2268
1.队列 队列是一个有序列表，可以用数组或是链表来实现。 遵循先进先出的原则。 示意图： 代码实现： Demo1: /** * 数组模拟队列 * * @author wangjie * @version V1.0 * @date 2019/12/23 */ public class ArrayQueueDemo { public static void main(St...
队列常用方法
Mrzhang__的专栏
12-05 2319
add             添加一个元素            如果队列满，则抛出IllegalStateException异常element             返回队列的头元素            如果队列为空，则抛出NoSuchElementException异常offer             添加一个元素并返回true            如果队列满，则返回falsepeek
java数据结构-----队列（常用方法）
咸鱼妹
09-28 1483
Java Queue常用方法 （1）获取头元素的方法 ①poll()获取并移出队列的头，如果次队列为空，则返回null。 ②remove()获取并移出此队列的头，如果此队列为空则抛出NoSuchElementException异常 （2）获取但是不移除 ①peek()获取队列的投，但是不移除队列的头，如果次队列为空，则返回null。 ②element()获取队列的头，但是不移除队列的头，如果队列为空，则将跑出NoSuchElementException异常。 （3）添加元素的方法 offer
队列使用
StarCrane_hlf的博客
09-26 151
队列使用 0.预备 include &amp;lt;queue&amp;gt; 队列是一种先进先出的数据结构 优先队列默认先大后小（可重载运算符） 1. 定义 普通队列: queue&amp;lt;数据类型&amp;gt;名字; 优先:priority_queue&amp;lt;数据类型&amp;gt;名字; 2.操作 p.push(a);//将a压入队列 p.pop();//弹出队首 p.top();//返回队首 p.empty();//检查...
【常用的队列总结】
weixin_47068446的博客
05-27 747
在 Java 中，队列（Queue）是一种常见的数据结构，它按照先进先出（FIFO）的原则管理元素。队列通常用于在数据集合中添加元素，并按照它们被添加的顺序移除元素。Java 提供了丰富的队列实现，可以满足不同场景下的需求。LinkedList 是 Java 中实现了 List 接口的类，它基于双向链表数据结构实现了列表的操作。除了实现了 List 接口之外，LinkedList 还实现了 Queue 接口，因此也可以用作队列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值