17.jdk源码阅读之LinkedBlockingQueue

最新推荐文章于 2024-08-28 20:58:28 发布

至真源

最新推荐文章于 2024-08-28 20:58:28 发布

阅读量1k

点赞数 7

分类专栏： JDK源码文章标签： java 缓存

本文为至真源原创，转载请注明出处，谢谢！

本文链接：https://blog.csdn.net/yunkongbian2616/article/details/140658721

版权

JDK源码专栏收录该内容

31 篇文章 0 订阅

订阅专栏

1. 写在前面

LinkedBlockingQueue 是 Java 并发包中的一个重要类，常用于生产者-消费者模式等多线程编程场景。上篇文章我们介绍了ArrayBlockingQueue，并且与LinkedBlockingQueue做了简单的对比，这篇文章我们来详细分析下LinkedBlockingQueue的源码，在此之前，我先抛出几个问题，看看大家之前有没有思考过：

LinkedBlockingQueue 如何实现线程安全？
LinkedBlockingQueue 的插入和移除操作是如何实现的？
LinkedBlockingQueue 的 size() 方法是线程安全的吗？
LinkedBlockingQueue 适用于哪些场景？
如何使用 LinkedBlockingQueue 实现一个简单的生产者-消费者模型？
LinkedBlockingQueue 的性能如何？如何优化？
如何处理 LinkedBlockingQueue 中的阻塞操作？
LinkedBlockingQueue 如何实现序列化？

2. 全局视角

在这里插入图片描述
LinkedBlockingQueue 直接继承自 AbstractQueue，而 AbstractQueue 又继承自 AbstractCollection。
LinkedBlockingQueue 实现了以下接口：

BlockingQueue
Serializable

2.1 AbstractCollection

AbstractCollection 是 Java 集合框架中的一个抽象类，它实现了 Collection 接口的大部分方法，但不包括 size() 和 iterator() 方法。LinkedBlockingQueue 通过继承 AbstractCollection，获得了 Collection 接口的大部分实现。

2.2 AbstractQueue

AbstractQueue 继承自 AbstractCollection，并实现了 Queue 接口的一部分方法。它提供了 offer()、poll() 和 peek() 方法的一些默认实现。LinkedBlockingQueue 通过继承 AbstractQueue，获得了 Queue 接口的一部分实现。

2.3 BlockingQueue

BlockingQueue 是 Java 并发包中的一个接口，它扩展了 Queue 接口，并增加了阻塞操作的方法，如 put(E e)、take()、offer(E e, long timeout, TimeUnit unit) 和 poll(long timeout, TimeUnit unit)。LinkedBlockingQueue 通过实现 BlockingQueue 接口，提供了这些阻塞操作的方法。

2.4 Serializable

Serializable 是一个标记接口，表示该类的实例可以被序列化。LinkedBlockingQueue 实现了 Serializable 接口，使其实例可以被序列化和反序列化。

3. 从使用说起

以下是一个完整的示例代码，展示了如何使用 LinkedBlockingQueue 实现生产者-消费者模式：

import java.util.concurrent.LinkedBlockingQueue;

// 生产者类
class Producer implements Runnable {
    private LinkedBlockingQueue<Integer> queue;

    public Producer(LinkedBlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Producing: " + i);
                queue.put(i); // 阻塞直到队列有空间
                Thread.sleep(500); // 模拟生产时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 消费者类
class Consumer implements Runnable {
    private LinkedBlockingQueue<Integer> queue;

    public Consumer(LinkedBlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                Integer item = queue.take(); // 阻塞直到队列有元素
                System.out.println("Consuming: " + item);
                Thread.sleep(1000); // 模拟消费时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 主类
public class ProducerConsumerExample {
    public static void main(String[] args) {
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5); // 创建一个容量为5的有界队列

        Thread producerThread = new Thread(new Producer(queue));
        Thread consumerThread = new Thread(new Consumer(queue));

        producerThread.start();
        consumerThread.start();
    }
}

3.1 创建 LinkedBlockingQueue 实例

LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5); // 创建一个容量为5的有界队列

这里创建了一个容量为 5 的 LinkedBlockingQueue 实例。这个队列将用于生产者和消费者之间的通信。

3.2 生产者类 Producer

class Producer implements Runnable {
    private LinkedBlockingQueue<Integer> queue;

    public Producer(LinkedBlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Producing: " + i);
                queue.put(i); // 阻塞直到队列有空间
                Thread.sleep(500); // 模拟生产时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Producer 类实现了 Runnable 接口。
在 run 方法中，生产者在循环中生产 10 个整数。
调用 queue.put(i) 将元素放入队列，如果队列已满，put 方法会阻塞直到有空间。
Thread.sleep(500) 用于模拟生产时间。

3.3 消费者类 Consumer

class Consumer implements Runnable {
    private LinkedBlockingQueue<Integer> queue;

    public Consumer(LinkedBlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                Integer item = queue.take(); // 阻塞直到队列有元素
                System.out.println("Consuming: " + item);
                Thread.sleep(1000); // 模拟消费时间
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Consumer 类也实现了 Runnable 接口。
在 run 方法中，消费者在一个无限循环中消费队列中的元素。
调用 queue.take() 从队列中取出元素，如果队列为空，take 方法会阻塞直到有元素。
Thread.sleep(1000) 用于模拟消费时间。

3.4 主类 ProducerConsumerExample

public class ProducerConsumerExample {
    public static void main(String[] args) {
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5); // 创建一个容量为5的有界队列

        Thread producerThread = new Thread(new Producer(queue));
        Thread consumerThread = new Thread(new Consumer(queue));

        producerThread.start();
        consumerThread.start();
    }
}

创建 LinkedBlockingQueue 实例。
创建生产者和消费者线程，并启动它们。

3.5 运行结果

运行上述代码后，你会看到生产者和消费者在控制台中输出的日志，展示了生产和消费的过程：

Producing: 0
Consuming: 0
Producing: 1
Producing: 2
Consuming: 1
Producing: 3
Producing: 4
Consuming: 2
...

4. LinkedBlockingQueue 如何实现线程安全？

LinkedBlockingQueue 使用两个独立的锁（putLock 和 takeLock）来分别控制插入和移除操作。它还使用条件对象（notEmpty 和 notFull）来管理队列的空和满状态，从而实现阻塞操作。

5. LinkedBlockingQueue 的插入和移除操作是如何实现的？

插入操作（put）：获取 putLock，如果队列已满，调用 notFull.await() 阻塞等待。插入元素后，更新元素数量并释放 putLock。如果队列之前为空，调用 signalNotEmpty() 唤醒等待的消费者。
移除操作（take）：获取 takeLock，如果队列为空，调用 notEmpty.await() 阻塞等待。移除元素后，更新元素数量并释放 takeLock。如果队列之前已满，调用 signalNotFull() 唤醒等待的生产者。

6. LinkedBlockingQueue 的 size() 方法是线程安全的吗？

size() 方法是线程安全的，因为它使用了一个 AtomicInteger 类型的 count 来跟踪队列中的元素数量。AtomicInteger 提供了原子操作，确保了线程安全性。

7. LinkedBlockingQueue 适用于哪些场景？

生产者-消费者模型：多个生产者线程和多个消费者线程之间的任务调度。
任务队列：在多线程环境下，用于存储和调度待处理任务。
异步处理：在异步处理场景中，用于存储和处理异步任务。

8. LinkedBlockingQueue 的性能如何？如何优化？

LinkedBlockingQueue 在高并发环境下性能较好，因为它使用了独立的锁来并行处理插入和移除操作。
优化可以从以下几个方面考虑：
- 调整队列的容量，以适应具体的应用场景。
- 使用批量操作（如 drainTo 方法）来减少锁竞争。
- 在高并发场景下，可以考虑使用其他高性能队列（如 ConcurrentLinkedQueue）来替代。

9. 如何处理 LinkedBlockingQueue 中的阻塞操作？

可以使用带超时的阻塞方法（如 offer(E e, long timeout, TimeUnit unit) 和 poll(long timeout, TimeUnit unit)）来避免永久阻塞。
在某些情况下，可以使用非阻塞方法（如 offer(E e) 和 poll()）来检查队列状态并采取相应的措施。

10. LinkedBlockingQueue 如何实现序列化？

LinkedBlockingQueue 实现了 Serializable 接口，因此它的实例可以被序列化和反序列化。
序列化时，会将队列中的元素和容量信息序列化。
反序列化时，会重新构造队列，并将元素添加到新的队列实例中。

系列文章

1.JDK源码阅读之环境搭建

2.JDK源码阅读之目录介绍

3.jdk源码阅读之ArrayList(上)

4.jdk源码阅读之ArrayList(下)

5.jdk源码阅读之HashMap

6.jdk源码阅读之HashMap（下）

7.jdk源码阅读之ConcurrentHashMap(上)

8.jdk源码阅读之ConcurrentHashMap（下）

9.jdk源码阅读之ThreadLocal

10.jdk源码阅读之ReentrantLock

11.jdk源码阅读之CountDownLatch

12.jdk源码阅读之CyclicBarrier

13.jdk源码阅读之Semaphore

14.jdk源码阅读之线程池(上)

15.jdk源码阅读之线程池(下)

16.jdk源码阅读之ArrayBlockingQueue

至真源

关注

7
点赞
踩
17

收藏

觉得还不错? 一键收藏
打赏
0
评论
17.jdk源码阅读之LinkedBlockingQueue

AbstractCollection 是 Java 集合框架中的一个抽象类，它实现了 Collection 接口的大部分方法，但不包括 size() 和 iterator() 方法。LinkedBlockingQueue 通过继承 AbstractCollection，获得了 Collection 接口的大部分实现。AbstractQueue 继承自 AbstractCollection，并实现了 Queue 接口的一部分方法。它提供了 offer()、poll() 和 peek() 方法的一些默认实现。
复制链接

扫一扫