java中阻塞队列和非阻塞队列的实现

目录

• 1. 什么是阻塞队列？
• 2. 什么是非阻塞队列？
• 3. 阻塞队列和非阻塞队列的区别
• 4. 使用场景和选择指南
• 4.1 阻塞队列的使用场景
• 4.2 非阻塞队列的使用场景
• 5. 阻塞队列和非阻塞队列的实现原理
• 5.1 阻塞队列的实现原理
• 5.2 非阻塞队列的实现原理
• 6. 示例代码
• 阻塞队列示例：ArrayblockingQueue
• 非阻塞队列示例：ConcurrentLinkedQueue
• 7. 总结

在 Java 中，**阻塞队列（Blocking Queue）和非阻塞队列（Non-Blocking Queue）**是两种用于并发编程的队列类型，它们在多线程环境中有不同的行为和用途。它们的主要区别在于对操作的处理方式：阻塞队列在操作无法立即完成时会阻塞线程，而非阻塞队列则立即返回或进行其他操作。

1. 什么是阻塞队列？

阻塞队列（Blocking Queue）是一种线程安全的队列，它在 Java 中位于 java.util.concurrent 包中。阻塞队列支持在队列为空时自动等待（即阻塞）直到有元素可以消费，或者在队列已满时自动等待直到有空间可以插入新元素。这种行为使得阻塞队列在生产者-消费者模型中非常有用。

阻塞队列的操作包括阻塞的插入操作和阻塞的删除操作。它们的主要方法有：

• put(E e)：如果队列已满，当前线程将被阻塞，直到队列有可用空间。
• take()：如果队列为空，当前线程将被阻塞，直到队列中有可用元素。

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

• ArrayBlockingQueue：一个有界的阻塞队ugUrgI列，基于数组实现。固定大小，支持公平性设置。

• LinkedBlockingQueue：一个可选有界的阻塞队列，基于链表实现。默认大小为 Integer.MAX_VALUE，适用于任务生产和消费速率不同的场景。

• PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列，基于堆实现，元素按优先级顺序出队。

• DelayQueue：一个支持延迟获取元素的无界阻塞队列，只有在元素的延迟期满后才能从队列中获取元素。

• SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等待一个相应的删除操作。适用于交换场景。

2. 什么是非阻塞队列？

非阻塞队列（Non-Blocking Queue）是一种不进行阻塞的线程安全队列。非阻塞队列不等待当前线程完成操作，而是立即返回或执行其他操作。它们通常使用 CAS（Compare-And-Swap） 操作来确保线程安全性，从而避免线程在等待锁时发生阻塞。

非阻塞队列的操作包括非阻塞的插入操作和非阻塞的删除操作。它们的主要方法有：

• offer(E e)：尝试插入元素到队列中，如果成功则返回 true，如果队列已满则立即返回 false。
• poll()：尝试从队列中取出一个元素，如果成功则返回元素，如果队列为空则立即返回 null。

Java 中常用的非阻塞队列有：

• ConcurrentLinkedQueue：一个基于链表的无界非阻塞队列，使用 CAS 操作来实现线程安全。适用于高并发场景。

• ConcurrentLinkedDeque：一个双端非阻塞队列，基于链表实现，支持在队列的两端进行插入和删除操作。

3. 阻塞队列和非阻塞队列的区别

• 阻塞与非阻塞：阻塞队列在读取或写入时可能会发生阻塞，而普通队列则不会发生这种情况。当一个线程尝试从空的普通队列中读取数据或向已满的普通队列中写入数据时，它将直接返回一个特定的值，而不是等待其他线程的操作。

• 同步与异步：阻塞队列通常用于同步处理场景，而普通队列通常用于异步处理场景。在同步处理场景下，多个线程之间需要协调工作，而在异步处理场景下，多个线程之间可以独立地进行各自的任务

• 性能差异：由于阻塞队列使用了锁机制，所以在高并发情况下可能会出现性能瓶颈；而非阻塞队列使用了原子操作和CAS指令，因此在高并发情况下具有更好的性能表现。

4. 使用场景和选择指南

阻塞队列和非阻塞队列各自适用于不同的场景。了解它们的特点和工作机制可以帮助开发者更好地选择合适的数据结构来解决并发问题。

4.1 阻塞队列的使用场景

• 生产者-消费者模型：阻塞队列最常见的应用场景就是生产者-消费者模型。在这种模型中，生产者线程不断地将任务放入队列，消费者线程不断地从队列中取任务。使用阻塞队列可以避免生产者或消费者线程在队列为空或已满时的忙等待，从而提高系统性能。

• 任务调度和工作线程池：在任务调度系统或工作线程池中，阻塞队列可以用于存放任务。线程池的工作线程可以从队列中取任务并执行，如果没有任务则自动等待直到有新任务到来。

• 延迟任务执行：DelayQueue 适用于需要在一定延迟后执行任务的场景，例如定时任务调度。

4.2 非阻塞队列的使用场景

• 高并发场景：非阻塞队列通常用于需要高并发访问的场景，因为它不使用锁而是依赖 CAS 操作来确保线程安全，从而减少了锁竞争的开销，能够提供更高的吞吐量。

• 低延迟应用：对于需要快速响应、低延迟的应用，非阻塞队列是非常适合的选择。例如，在金融交易系统或高性能计算系统中，需要非常快速地处理请求而不受锁的影响。

• 无界队列：非阻塞队列通常是无界的，例如 ConcurrentLinkedQueue，这意味着它们不会限制队列大小，但要小心使用，避免内存溢出。

5. 阻塞队列和非阻塞队列的实现原理

5.1 阻塞队列的实现原理

阻塞队列的实现依赖于内部锁和条件变量（Condition）来实现线程同步。例如，ArrayBlockingQueue 的实现如下：

• 插入操作（put()）：如果队列已满，插入线程会被放入“等待可用空间”的条件队列中，直到有其他线程取走元素并唤醒它。
• 取出操作（take()）：如果队列为空，取出线程会被放入“等待元素”的条件队列中，直到有其他线程插入元素并唤醒它。

这些方法通过 ReentrantLock 和 Condition 来实现同步控制：

public void put(E e) throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            notFull.await();  // 等待队列非满
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

5.2 非阻塞队列的实现原理

非阻塞队列通常使用 CAS（Compare-And-Swap）操作来实现线程安全。ConcurrentLinkedQueue 是一个典型的非阻塞队列，它通过链表的方式实现。其 offer() 和 poll() 方法实现如下：

• 插入操作（offer()）：使用 CAS 操作来将新节点插入到链表的末尾。如果失败则不断重试，直到成功为止。

• 取出操作（poll()）：使用 CAS 操作来获取并移除链表的头节点，同样会在操作失败时进行重试，直到成功。

public boolean offer(E e) {
    final Node<E> newNode = new Node<>(e);
    for (Node<E> t = tail, p = t;;) {
        Node<E> q = p.next;
        if (q

 == null) {
            if (p.casNext(null, newNode)) {
                if (p != t)
                    casTail(t, newNode);  // 使用 CAS 更新尾编程客栈节点
                return true;
            }
        } else if (p == q)
            p = (t != (t = tail)) ? t : head;
        else
            p = (p != t && t != (t = tail)) ? t : q;
    }
}

6. 示例代码

下面是一个使用阻塞队列和非阻塞队列的简单示例：

阻塞队列示例：ArrayBlockingQueue

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExample {
    public stjsatic void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.println("生产者生产: " + i);
                    queue.put(i);  // 阻塞插入操作
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
       js         while (true) {
                    Integer item = queue.take();  // 阻塞取出操作
                    System.out.println("消费者消费: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

非阻塞队列示例：ConcurrentLinkedQueue

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

public class NonBlockingQueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new ConcurrentLinkedQueue<>();

        // 添加元素
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);

        // 取出元素
       编程客栈 Integer item;
        while ((item = queue.poll()) != null) {
            System.out.println("取出: " + item);
        }
    }
}

7. 总结

阻塞队列和非阻塞队列在 Java 并发编程中具有不同的应用场景和特点。阻塞队列通过内部锁和条件变量实现线程安全，适用于生产者-消费者模型和任务调度等场景。非阻塞队列通过 CAS 操作实现线程安全，适用于高并发和低延迟场景。

到此这篇关于java中阻塞队列和非阻塞队列的实现的文章就介绍到这了,更多相关java 阻塞队列和非阻塞队列内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！