菜鸟看源码之LinkedBlockingQueue

已于 2024-04-10 19:43:25 修改
阅读量492 收藏
点赞数
文章标签： LinkedBlockingQueue Java Collection
于 2018-03-15 21:45:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leilifengxingmw/article/details/79561804
版权

首先扯点别的：已经不记得上次是什么时候做仰卧起坐的了，现在重新开始锻炼起来，腹肌还是得保持的。但是刚做了两天就感觉小腹酸疼。做20个都得咬牙坚持。明天继续做。

今天分析一下LinkedBlockingQueue的源码。LinkedBlockingQueue 是基于链表的阻塞队列，按照先进先出的顺序来排列元素。默认长度可以达到Integer.MAX_VALUE 。也可以指定LinkedBlockingQueue最大长度。添加的元素不能为null。

LinkedBlockingQueue的继承结构

在这里插入图片描述

节点类

static class Node <E> {
    E item;
    Node <E> next;
    Node(E x) {
        item = x;
    }
}

注意一下：头节点(下文一律称作head)的item为null。尾节点(下文一律称作last)的next为null。

相关成员变量：

    //容量上限，默认是Integer.MAX_VALUE
    private final int capacity;

    //元素的个数
    private final AtomicInteger count = new AtomicInteger();

     //头节点，head.item==null
    transient Node<E> head;

    //尾节点，last.next==null
    private transient Node<E> last;

	//如果要取出元素，要持有这个锁
    private final ReentrantLock takeLock = new ReentrantLock();

    //标记队列是否为空
    private final Condition notEmpty = takeLock.newCondition();

    //如果要添加元素，要持有这个锁
    private final ReentrantLock putLock = new ReentrantLock();

    //标记队列是否已满
    private final Condition notFull = putLock.newCondition();

构造方法

创建一个容量是Integer.MAX_VALUE的LinkedBlockingQueue

 public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

创建一个容量是capacity的LinkedBlockingQueue

public LinkedBlockingQueue(int capacity) {
    if(capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node <E> (null);
}

创建一个容量是Integer.MAX_VALUE的LinkedBlockingQueue，并把集合c中的所有元素加入LinkedBlockingQueue。

public LinkedBlockingQueue(Collection <? extends E> c) {
    //初始化容量为Integer.MAX_VALUE
    this(Integer.MAX_VALUE);
    final ReentrantLock putLock = this.putLock;
    putLock.lock(); // Never contended, but necessary for visibility
    try {
        int n = 0;
        for(E e: c) {
            if(e == null) throw new NullPointerException();
            if(n == capacity) throw new IllegalStateException("Queue full");
            enqueue(new Node <E> (e));
            ++n;
        }
        count.set(n);
    } finally {
        putLock.unlock();
    }
}

把元素添加到队列的末尾

private void enqueue(Node <E> node) {
    // assert putLock.isHeldByCurrentThread();
    // assert last.next == null;
    last = last.next = node; //等价于 last.next = node;last =last.next;
}

在添加集合c中的元素到LinkedBlockingQueue 中的时候，如果集合c中存在元素为null，则抛出空指针异常，如果集合c中的元素个数超过了LinkedBlockingQueue的容量，抛出一个队列已满的异常。

相关方法

LinkedBlockingQueue 的 offer(E e) 方法

添加一个元素到队列尾部，如果队列满了，返回false，不会添加。

public boolean offer(E e) {
    if(e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    if(count.get() == capacity) return false;
    //这里将c置为-1，成功添加一个元素以后，
    int c = -1;
    Node <E> node = new Node <E> (e);
    final ReentrantLock putLock = this.putLock;
    //注释0处，先获取锁，
    putLock.lock();
    try {
        if(count.get() < capacity) {
            //队列未满，添加元素
            enqueue(node);
            c = count.getAndIncrement(); //添加完元素后count要加1。
            if(c + 1 < capacity) //如果添加元素以后，队列没有满
                notFull.signal(); //唤醒notFull上等待的线程，
        }
    } finally {
        //释放锁
        putLock.unlock();
    }
    //注释1处，表示此时队列不为空，唤醒notEmpty上等待的线程。
    if(c == 0) 
        signalNotEmpty();
    return c >= 0;
}

注释0处，先获取锁，获取了锁，再检查一次队列是否满了，没有满的话，就添加到队尾，返回true。

注释1处，表示此时队列不为空，唤醒notEmpty上等待的线程。这个方法只会在put或offer方法中被调用。

 private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}
LinkedBlockingQueue 的 boolean offer(E e, long timeout, TimeUnit unit)

在获取锁之后，最多等待 unit 的时间，如果添加成功，返回true，否则返回false。在获取锁的等待过程中是可以被中断的。被中断则抛出
InterruptedException。

 public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
    if(e == null) throw new NullPointerException();
    long nanos = unit.toNanos(timeout);
    int c = -1;
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        while(count.get() == capacity) {
            if(nanos <= 0) return false;
            nanos = notFull.awaitNanos(nanos);
        }
        enqueue(new Node <E> (e));
        c = count.getAndIncrement();
        if(c + 1 < capacity) notFull.signal();
    } finally {
        putLock.unlock();
    }
    if(c == 0) signalNotEmpty();
    return true;
}
LinkedBlockingQueue 的 void put(E e) 方法。

添加一个元素，如果队列已满的话，这个方法会阻塞，直到成功添加元素或者当前线程被中断。没有返回值。

public void put(E e) throws InterruptedException {
    if(e == null) throw new NullPointerException();
    int c = -1;
    Node <E> node = new Node <E> (e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    //使用lockInterruptibly方法，可以响应中断
    putLock.lockInterruptibly();
    try {
        //如果队列已满，就阻塞
        while(count.get() == capacity) {
            notFull.await();
        }
        //直到队列不满的时候，才添加元素
        enqueue(node);
        c = count.getAndIncrement();
        if(c + 1 < capacity) //如果队列未满，则唤醒notFull上等待的线程
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    if(c == 0) //表示队列不为空，唤醒notEmpty上等待的线程
        signalNotEmpty();
}
LinkedBlockingQueue 的 take() 方法

从队列中获取并删除一个元素， 如果队列为空，则阻塞，直到获取元素，或者被中断。

 public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        //队列为空，则阻塞
        while(count.get() == 0) {
            notEmpty.await();
        }
        //直到队列不为空，才获取数据
        x = dequeue();
        c = count.getAndDecrement();
        if(c > 1) //队列不为空，唤醒notEmpty上等待的线程
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if(c == capacity) //队列未满，唤醒notFull上等待的线程
        signalNotFull();
    return x;
}

注意：take方法内部调用 dequeue 方法，会导致返回的元素从队列中删除。

LinkedBlockingQueue 的 dequeue() 方法
private E dequeue() {
    // assert takeLock.isHeldByCurrentThread();
    // assert head.item == null;
    Node <E> h = head;
    Node <E> first = h.next;
    h.next = h; // help GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

将head.next 赋值给 head，相当于删除了一个节点。

唤醒notFull上等待的线程，这个方法只会在take或poll方法中 被调用

 private void signalNotFull() {
     final ReentrantLock putLock = this.putLock;
     putLock.lock();
     try {
         notFull.signal();
     } finally {
         putLock.unlock();
     }
 }
LinkedBlockingQueue 的 poll() 方法
public E poll() {
    final AtomicInteger count = this.count;
    if(count.get() == 0)
        return null;
    E x = null;
    int c = -1;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        if(count.get() > 0) {
            //如果队列不为空，调用dequeue获取并删除元素
            x = dequeue();
            c = count.getAndDecrement();
            if(c > 1) //获取元素以后，如果队列不为空，唤醒notEmpty上等待的线程
                notEmpty.signal();
        }
    } finally {
        takeLock.unlock();
    }
    if(c == capacity) //获取元素以后，如果队列未满，唤醒notFull上等待的线程
        signalNotFull();
    return x;
}

跟 take 方法类似，只是这个方法如果获取不到元素会一直等待，锁不会被中断。

LinkedBlockingQueue 的 public E poll(long timeout, TimeUnit unit) 方法

获取锁以后，在指定时间内获取元素，直到时间耗尽返回null，或者正常返回元素，或者被中断，抛出 InterruptedException。

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    E x = null;
    int c = -1;
    long nanos = unit.toNanos(timeout);
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while(count.get() == 0) {
            if(nanos <= 0)
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        x = dequeue();
        c = count.getAndDecrement();
        if(c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if(c == capacity)
        signalNotFull();
    return x;
}
LinkedBlockingQueue 的 E peek() 方法

获取队列中第一个元素，不会删除元素。

public E peek() {
    if(count.get() == 0)
        return null;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        Node <E> first = head.next;
        if(first == null)
            return null;
        else
            return first.item;
    } finally {
        takeLock.unlock();
    }
}

参考链接：

leilifengxingmw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
LinkedBlockingQueue
baidu_39458769的博客
12-23 104
LinkedBlockingQueue 是阻塞式的无界队列 构造函数，初始化capacity为int最大值，创建头尾节点 public LinkedBlockingQueue() { this(Integer.MAX_VALUE); } public LinkedBlockingQueue(int capacity) { if (capacity <= 0) throw new IllegalArgumentException();
阻塞队列--LinkedBlockingQueue
weixin_34185512的博客
01-13 131
什么叫线程安全？线程安全就是每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的。 线程安全就是说多线程访问同一代码，不会产生不确定的结果。 并行和并发区别1、并行是指两者同时执行一件事，比如赛跑，两个人都在不停的往前跑；2、并发是指资源有限的情况下，两者交替轮流使用资源，比如一段路(单核CPU资源)同时只能过一个人，A走一段后，让给B，B用完继续给A，交替使用，目的是提...
【细谈Java并发】谈谈LinkedBlockingQueue
热门推荐
颤抖吧腿子
10-26 12万+
最近在看concurrent包的知识，看到LinkedBlockingQueue，发现一篇好文推荐给大家。 原文地址：【细谈Java并发】谈谈LinkedBlockingQueue 1、简介 上篇我们介绍了ArrayBlockingQueue的相关方法的原理，这一篇我们来学习一下ArrayBlockingQueue的“亲戚” LinkedBlockingQueue。在集合框架里，想必大家都用过Ar...
JDK容器学习之Queue：LinkedBlockingQueue
06-19
首先，我们来看一下`LinkedBlockingQueue`的底层数据结构。与数组结构的`ArrayBlockingQueue`不同，`LinkedBlockingQueue`使用单向链表实现，这使得插入和删除操作的效率相对较高，因为它们只需要修改相邻节点的引用...
LinkedBlockingQueue + 单向链表基本结构
04-07
在分析`SingleLinked.java`源码时，我们可以看到具体如何实现这些概念。文件中的类可能定义了一个简单的单向链表节点，包括节点的数据成员（如数据item和指向下一个节点的引用next）以及可能的辅助方法，例如插入新...
详细分析Java并发集合LinkedBlockingQueue的用法
08-27
详细分析Java并发集合LinkedBlockingQueue的用法 Java并发集合LinkedBlockingQueue是Java并发集合中的一种阻塞队列实现，使用链表方式实现的阻塞队列。LinkedBlockingQueue的实现主要包括链表实现、插入和删除节点...
java中LinkedBlockingQueue与ArrayBlockingQueue的异同
09-01
这两种队列在很多方面都有相似之处，但在实现机制和性能特性上存在一些差异。 **相同点** 1. **接口实现**：两者都是`BlockingQueue`接口的实现，提供了`put`、`take`等阻塞操作，使得生产者线程在队列满时会被...
linkedblockingqueue
08-25
《LinkedBlockingQueue深度解析与应用实践》 在Java并发编程领域，`LinkedBlockingQueue`是一个不可或缺的工具。作为`java.util.concurrent`包中的一个线程安全的队列，它基于链表结构实现，具备先进先出（FIFO）的...
Java多线程--阻塞队列
BtWangZhi的博客
02-08 582
如果队列满了，添加元素的线程将会陷入等待状态，而队列为空，获取元素的线程将会陷入等待。有了BlockingQueue，我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程。这一切都交给了BlockingQueue。 ...
LinkedBlockingQueue的put,add和offer的区别
wjy320的专栏
06-27 1604
      最近在学习&lt;&lt;Java并发编程实践&gt;&gt;，有很多java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一，顾名思义这是一个阻塞的线程安全的队列，底层应该采用链表实现。        看其API的时候发现，添加元素的方法竟然有三个：add,put,offer。 且这三个元素都是向队列尾部添加元素的意思。于是我产...
BlockingQueue之LinkedBlockingQueue
Chilx的博客
05-08 770
文章目录1 核心参数2 构造方法3 核心方法 LinkedBlockingQueue LinkedBlockingQueue是一种基于单向链表 的阻塞队列。其队头和队尾分别有两个指针来控制，所以生产者和消费者可以采用独立的锁来控制数据同步，也就意味着在高并发的情况下，生产者和消费者是可以同时操作队列的，从而提高了队列的并发性。 ​ 因为生产者和消费者是不同的锁控制的，所以记录队列总数count是一个AtomicInteger的原子变量 1 核心参数 public class LinkedBlockin
LinkedBlockingQueue使用
红目香薰
06-03 4267
poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的 import java.util.concurrent.LinkedBlockingQueue; public class Main { public static void main(String[] args) { LinkedBlockingQueue<Integer> queue =new LinkedBlockingQueue<Integer>(); for (int i =.
手写LinkedBlockingQueue
qewgd的博客
03-09 340
原作者：老铁123　　　 出处：https://blog.csdn.net/qewgd/article/details/88363745　 本文归作者【老铁123】和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 LinkedBlockingQueue基于链表的阻塞队列，生产者消费者模型应用。 import java.util....
Android多线程之LinkedBlockingQueue源码解析
weixin_34306676的博客
08-31 471
阻塞队列系列 Android多线程之ArrayBlockingQueue源码解析 Android多线程之SynchronousQueue源码解析 Andorid多线程之DelayQueue源码分析 public class LinkedBlockingQueue&lt;E&gt; extends AbstractQueue&lt;E&gt; implements Blockin...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值