java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java 阻塞队列和非阻塞队列

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

作者：Flying_Fish_Xuan

在Java并发编程中,阻塞队列和非阻塞队列是两种主要的队列类型,分别适用于不同的场景,了解这两种队列的特点和工作机制,可以帮助开发者更好地选择合适的数据结构解决并发问题

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

1. 什么是阻塞队列？

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

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

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

2. 什么是非阻塞队列？

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

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

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

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

4. 使用场景和选择指南

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

4.1 阻塞队列的使用场景

4.2 非阻塞队列的使用场景

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

5.1 阻塞队列的实现原理

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

这些方法通过 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() 方法实现如下：

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 static 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 {
                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 阻塞队列和非阻塞队列内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文