当前位置： 首页 > news >正文

Java中常用的七种队列你了解多少?

news 来源：原创 2025/4/19 19:23:34

文章目录

    • Java中常用的七种队列你了解多少?
    • ArrayBlockingQueue队列如何使用？
      • 添加元素到队列
      • 获取队列中的元素
      • 遍历队列
    • LinkedBlockingQueue队列如何使用？
      • 1. 创建SynchronousQueue对象
      • 2. 添加元素到队列
      • 3. 获取队列中的元素
      • 4. 遍历队列
    • SynchronousQueue队列如何使用？
      • 创建SynchronousQueue对象
      • 添加元素到队列
      • 获取队列中的元素
      • 遍历队列
    • LinkedTransferQueue队列如何使用？
      • 1. 创建LinkedTransferQueue对象
      • 2. 添加元素到队列
      • 3. 获取队列中的元素
      • 4. 遍历队列
    • ConcurrentLinkedQueue队列如何使用？
      • 1. 创建DelayQueue对象
      • 2. 添加元素到DelayQueue
      • 3. 获取DelayQueue中的元素
      • 4. 自定义元素类
    • DelayQueue队列如何使用？
      • 创建DelayQueue对象
      • 添加元素到DelayQueue
      • 获取DelayQueue中的元素
    • 总结:
  • 结语

Java中常用的七种队列你了解多少?

Java中常用的队列有以下几种：

  1. ArrayBlockingQueue：一个基于数组结构的有界阻塞队列，按照先进先出的原则对元素进行排序。
  2. LinkedBlockingQueue：一个基于链表结构的有界阻塞队列，按照先进先出的原则对元素进行排序。
  3. PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。
  4. DelayQueue：一个支持延时获取元素的无界阻塞队列。
  5. SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等待另一个线程的移除操作，否则插入操作一直处于阻塞状态。
  6. LinkedTransferQueue：一个基于链表结构的无界阻塞队列，支持生产者消费者模式。
  7. ConcurrentLinkedQueue：一个基于链表结构的无界并发队列，按照先进先出的原则对元素进行排序。

这些队列都实现了Queue接口或其子接口，可以根据不同的场景和需求选择合适的队列。在并发场景下，应当注意队列的线程安全性以及对并发操作的支持程度。

ArrayBlockingQueue队列如何使用？

ArrayBlockingQueue是Java中的一个线程安全的队列，它是一种基于数组实现的有界队列。下面介绍一下ArrayBlockingQueue队列的使用方法。

创建ArrayBlockingQueue对象
可以使用new关键字创建ArrayBlockingQueue对象。

ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(capacity);

其中，capacity参数表示队列的容量。

添加元素到队列

可以使用add方法向队列中添加元素，如果队列已满，则会抛出IllegalStateException异常。

queue.add("wx:libin9iOak");

也可以使用offer方法向队列中添加元素，如果队列已满，则返回false。

boolean result = queue.offer("wx:libin9iOak");

还可以使用put方法向队列中添加元素，如果队列已满，则当前线程会被阻塞，直到有其他线程从队列中删除元素。

queue.put("wx:libin9iOak");

获取队列中的元素

可以使用take方法获取队列中的元素，如果队列为空，则当前线程会被阻塞，直到有其他线程向队列中添加元素。

String element = queue.take();

也可以使用poll方法获取队列中的元素，如果队列为空，则返回null。

String element = queue.poll();

还可以使用poll方法设置超时时间，如果在指定的时间内没有获取到元素，则返回null。

String element = queue.poll(timeout, unit);

遍历队列

可以使用迭代器遍历队列中的元素。

Iterator<String> iterator = queue.iterator();
while(iterator.hasNext()) {
   String element = iterator.next();
   // do something with the element
}

也可以使用for-each循环遍历队列中的元素。

for(String element : queue) {
   // do something with the element
}

ArrayBlockingQueue在生产者线程和消费者线程之间提供了一种同步交互的机制，能够有效地控制线程之间的交互。同时，由于它是一种有界队列，因此在使用时需要注意队列的容量，以免发生队列溢出。

LinkedBlockingQueue队列如何使用？

SynchronousQueue是Java中的一个线程安全的队列，它是一种没有缓冲的队列，其中每个插入操作必须等待另一个线程的删除操作，反之亦然。下面介绍一下SynchronousQueue队列的使用方法。

1. 创建SynchronousQueue对象

可以使用new关键字创建SynchronousQueue对象。

 
SynchronousQueue<String> queue = new SynchronousQueue<>();

2. 添加元素到队列

SynchronousQueue是一种没有缓冲的队列，因此不能直接将元素添加到队列中。它的插入操作必须等待另一个线程的删除操作。可以使用put方法向队列中添加元素，如果没有等待的消费者线程，则当前线程会被阻塞，直到有消费者线程来获取元素。

 
queue.put("wx:libin9iOak");

3. 获取队列中的元素

可以使用take方法获取队列中的元素，如果队列为空，则当前线程会被阻塞，直到有生产者线程添加元素。

 
String element = queue.take();

4. 遍历队列

SynchronousQueue是一种没有缓冲的队列，因此不支持遍历操作。

SynchronousQueue在生产者线程和消费者线程之间提供了一种同步交互的机制，能够有效地控制线程之间的交互。但是需要注意的是，由于它是一种没有缓冲的队列，因此在使用时需要确保生产者线程和消费者线程之间的数量平衡，否则可能会导致线程阻塞或队列溢出。

Regenerate response

SynchronousQueue队列如何使用？

SynchronousQueue是Java中的一个线程安全的队列，它是一种没有缓冲的队列，其中每个插入操作必须等待另一个线程的删除操作，反之亦然。下面介绍一下SynchronousQueue队列的使用方法。

创建SynchronousQueue对象

可以使用new关键字创建SynchronousQueue对象。

 ```

SynchronousQueue queue = new SynchronousQueue<>();
```

添加元素到队列

SynchronousQueue是一种没有缓冲的队列，因此不能直接将元素添加到队列中。它的插入操作必须等待另一个线程的删除操作。可以使用put方法向队列中添加元素，如果没有等待的消费者线程，则当前线程会被阻塞，直到有消费者线程来获取元素。

 ```

queue.put(“wx:libin9iOak”);
```

获取队列中的元素

可以使用take方法获取队列中的元素，如果队列为空，则当前线程会被阻塞，直到有生产者线程添加元素。

 ```

String element = queue.take();
```

遍历队列

SynchronousQueue是一种没有缓冲的队列，因此不支持遍历操作。

SynchronousQueue在生产者线程和消费者线程之间提供了一种同步交互的机制，能够有效地控制线程之间的交互。但是需要注意的是，由于它是一种没有缓冲的队列，因此在使用时需要确保生产者线程和消费者线程之间的数量平衡，否则可能会导致线程阻塞或队列溢出。

LinkedTransferQueue队列如何使用？

LinkedTransferQueue是Java中的一个线程安全的队列，它是基于链表实现的无界队列，支持高效的并发访问。相比于ConcurrentLinkedQueue，它多了一种阻塞等待的机制。下面介绍一下LinkedTransferQueue队列的使用方法。

1. 创建LinkedTransferQueue对象

可以使用new关键字创建LinkedTransferQueue对象。

          
LinkedTransferQueue<String> queue = new LinkedTransferQueue<>();

2. 添加元素到队列

可以使用add、offer或transfer方法将元素添加到队列中。

  queue.add("wx:libin9iOak");
queue.offer("weix:libin9iOak");
queue.transfer("element3");

其中，add方法在队列已满时会抛出异常，而offer方法则会返回false。而transfer方法则是一种阻塞等待的机制，它会将元素立即转移给等待的消费者线程，如果没有等待的消费者线程，则当前线程会被阻塞，直到有消费者线程来获取元素。

3. 获取队列中的元素

可以使用poll方法获取队列中的元素，如果队列为空，则返回null。

          
String element = queue.poll();

也可以使用take方法获取队列中的元素，如果队列为空，则当前线程会被阻塞，直到有生产者线程添加元素。

          
String element = queue.take();

4. 遍历队列

可以使用forEach方法遍历队列中的元素。

          
queue.forEach(System.out::println);

也可以使用迭代器遍历队列中的元素。

          Iterator<String> iterator = queue.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

LinkedTransferQueue支持高效的并发访问，并且它提供了一种阻塞等待的机制，可以更加灵活地控制线程之间的交互。但是需要注意的是，由于它是基于链表实现的，因此在进行遍历或删除操作时，需要注意多线程并发修改的问题。

ConcurrentLinkedQueue队列如何使用？

DelayQueue是Java中的一个阻塞队列，它可以支持延时获取元素的功能。在DelayQueue中，每个元素都有一个过期时间，只有当元素的过期时间到了才能被获取，否则元素一直处于阻塞状态。下面介绍一下DelayQueue队列的使用方法。

1. 创建DelayQueue对象

可以使用new关键字或者工具类Executors创建DelayQueue对象。

     
DelayQueue<MyDelayedElement> delayQueue = new DelayQueue<>();

其中MyDelayedElement是自定义的实现了Delayed接口的元素类，实现getDelay方法用于返回元素的过期时间。

2. 添加元素到DelayQueue

可以使用add或offer方法将元素添加到DelayQueue中。

     delayQueue.add(new MyDelayedElement("wx:libin9iOak", 1000));
delayQueue.offer(new MyDelayedElement("weix:libin9iOak", 2000));

其中，第二个参数是元素的过期时间，单位为毫秒。

3. 获取DelayQueue中的元素

可以使用take方法获取DelayQueue中的元素，如果没有可用的元素，则线程会一直处于阻塞状态。

     
MyDelayedElement element = delayQueue.take();

也可以使用poll方法获取DelayQueue中的元素，如果没有可用的元素，则返回null。

     
MyDelayedElement element = delayQueue.poll();

4. 自定义元素类

MyDelayedElement是一个自定义的实现了Delayed接口的元素类，下面是一个简单的示例代码。

     public class MyDelayedElement implements Delayed {
    private String name; // 元素名称
    private long expireTime; // 过期时间

    public MyDelayedElement(String name, long delay) {
        this.name = name;
        this.expireTime = System.currentTimeMillis() + delay;
    }

    // 获取元素的过期时间
    @Override
    public long getDelay(TimeUnit unit) {
        long diff = expireTime - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }

    // 按照过期时间排序
    @Override
    public int compareTo(Delayed other) {
        long diff = this.getDelay(TimeUnit.MILLISECONDS) - other.getDelay(TimeUnit.MILLISECONDS);
        return Long.compare(diff, 0);
    }

    // 元素业务逻辑
    public void doBusiness() {
        System.out.println("Element " + name + " has expired");
    }
}

在上面的示例代码中，元素的过期时间是由创建元素时指定的delay参数和当前时间计算得出的。在getDelay方法中，返回元素的过期时间与指定时间单位的差值，这个差值会用于元素的排序。在compareTo方法中，按照过期时间从小到大排序。在doBusiness方法中，执行元素的业务逻辑。

总之，DelayQueue可以用于实现一些延时操作，例如定时任务调度、缓存失效等。在使用时，需要注意元素的过期时间和业务逻辑的处理。

DelayQueue队列如何使用？

DelayQueue是Java中的一个阻塞队列，它可以支持延时获取元素的功能。在DelayQueue中，每个元素都有一个过期时间，只有当元素的过期时间到了才能被获取，否则元素一直处于阻塞状态。下面介绍一下DelayQueue队列的使用方法。

创建DelayQueue对象

可以使用new关键字或者工具类Executors创建DelayQueue对象。

DelayQueue<MyDelayedElement> delayQueue = new DelayQueue<>();

其中MyDelayedElement是自定义的实现了Delayed接口的元素类，实现getDelay方法用于返回元素的过期时间。

添加元素到DelayQueue

可以使用add或offer方法将元素添加到DelayQueue中。

delayQueue.add(new MyDelayedElement("wx:libin9iOak", 1000));
delayQueue.offer(new MyDelayedElement("weix:libin9iOak", 2000));

其中，第二个参数是元素的过期时间，单位为毫秒。

获取DelayQueue中的元素

可以使用take方法获取DelayQueue中的元素，如果没有可用的元素，则线程会一直处于阻塞状态。

MyDelayedElement element = delayQueue.take();

也可以使用poll方法获取DelayQueue中的元素，如果没有可用的元素，则返回null。

MyDelayedElement element = delayQueue.poll();

自定义元素类
MyDelayedElement是一个自定义的实现了Delayed接口的元素类，下面是一个简单的示例代码。


public class MyDelayedElement implements Delayed {
   private String name; // 元素名称
   private long expireTime; // 过期时间




   public MyDelayedElement(String name, long delay) {
       this.name = name;
       this.expireTime = System.currentTimeMillis() + delay;
   }
   
   // 获取元素的过期时间
   @Override
   public long getDelay(TimeUnit unit) {
       long diff = expireTime - System.currentTimeMillis();
       return unit.convert(diff, TimeUnit.MILLISECONDS);
   }
   
   // 按照过期时间排序
   @Override
   public int compareTo(Delayed other) {
       long diff = this.getDelay(TimeUnit.MILLISECONDS) - other.getDelay(TimeUnit.MILLISECONDS);
       return Long.compare(diff, 0);
   }
   
   // 元素业务逻辑
   public void doBusiness() {
       System.out.println("Element " + name + " has expired");
   }

}

在上面的示例代码中，元素的过期时间是由创建元素时指定的delay参数和当前时间计算得出的。在getDelay方法中，返回元素的过期时间与指定时间单位的差值，这个差值会用于元素的排序。在compareTo方法中，按照过期时间从小到大排序。在doBusiness方法中，执行元素的业务逻辑。

总之，DelayQueue可以用于实现一些延时操作，例如定时任务调度、缓存失效等。在使用时，需要注意元素的过期时间和业务逻辑的处理。

总结:

ArrayBlockingQueue是一种有界队列，它可以设定最大容量，当队列满时，新增元素会被阻塞；LinkedBlockingQueue是一种无界队列，它将新增元素放在队列的尾部，获取元素时从队列的头部开始获取；PriorityBlockingQueue是一种带有优先级的队列，它会根据元素的优先级顺序来进行排序；LinkedTransferQueue是一种基于链表实现的无界队列，它支持高效的并发访问，并且它提供了一种阻塞等待的机制；

ConcurrentLinkedQueue是一种基于链接节点的无界线程安全队列，支持高性能的并发操作。

在这里插入图片描述

结语

如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、评论、收藏➕关注，您的支持是我坚持写作最大的动力。

相关文章：

  • 【YOLO系列】YOLOv5超详细解读（网络详解）
  • Git系列：常见报错处理
  • Java 操作图片进行缩放旋转翻转加水印
  • π型滤波器 计算_π型滤波电路
  • 【OJ比赛日历】快周末了，不来一场比赛吗？ #03.04-03.10 #12场
  • 数据结构:堆的实现与建堆时间复杂度分析
  • 90%的人都不算会爬虫，这才是真正的技术，从0到高手的进阶
  • Spring Boot 3.0系列【5】基础篇之应用配置文件
  • 数据结构六大排序
  • IPv4地址细讲
  • 植物大战 二叉搜索树——C++
  • RV1126 在Ubuntu18.04开发环境搭建
  • 如何根据IP地址判断是IPv4还是IPv6
  • js几种对象创建方式
  • Android TV UI开发常用知识
  • 【解锁技能】学会Python条件语句的终极指南！
  • 2023年“网络安全”赛项浙江省金华市选拔赛 任务书
  • 2023年全国最新二级建造师精选真题及答案9
  • 《金山区提信心扩需求稳增长促发展行动方案》的通知
  • 吉林大学 程序设计基础 2022级 实验复盘 2.23
  • 上海奉贤这所九年一贯制学校将迎首批新生，有何特色？
  • 别把癌症当鼻炎，爱吃这类食物的人，尤其要警惕
  • 习近平抵达柬埔寨金边国际机场发表书面讲话（全文）
  • 多家期刊就AI辅助写作表态：不想让放弃思考毁了一代人
  • 专家建议提高空气质量“良”的标准，治理水平已具备提标基础