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

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

news 来源：原创 2024/5/18 22:15:54

文章目录

- 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中常用的队列有以下几种：

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

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

```

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

添加元素到队列

```

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

获取队列中的元素

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

```

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

遍历队列

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对象

可以使用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");
   }

}

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

总结:

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

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

在这里插入图片描述