JUC--LinkedBlockingQueue源码分析 (基于JDK1.8) 未完待续

1 概述

LinkedBlockingQueue是一个有界性可选的阻塞队列,也就是再初始化的时候如果设置了大小,则大小就是固定的,否则队列的大小为Integer.MAX_VALUE。通常为了防止数据的膨胀,我们通常再初始化的时候给链表设置一个初始大小。

LinkedBlockingQueue是基于链表实现的一个FIFO队列,链表的首节点是添加时间最久的数据,而链表的尾节点是最早添加的数据,所以数据的添加是从尾节点开始。

2 使用示例

LinkedBlockingQueue比较适合于高并发的场景使用,具体原因我们会在文章后续内容中说明,接下来我们来看一下LinkedBlockingQueue的简用。

/**
 * 演示LinkedBlockingQueue的使用
 *
 * @author: LIUTAO
 * @Date: Created in 2018/9/28  11:15
 * @Modified By:
 */
public class LinkedBlockingQueueDemo {
    static  LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(5);

    public static void main(String[] args) {

        //producer线程
        for (int i = 0; i < 10 ; i++){
            new Thread(() -> {
                try {
                    linkedBlockingQueue.put(Thread.currentThread().getName());
                    System.out.println(Thread.currentThread().getName() + "have put");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        //consumer线程
        for (int i = 0; i < 10 ; i++){
            new Thread(() -> {
                try {
                    System.out.println(linkedBlockingQueue.take() + "have got");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

可以看出LinkedBlockingQueue和ArrayBlockingQueue的使用方法基本相同,不同的是他们的使用场景。

3 类的继承关系

从上图我们可以看出LinkedBlockingQueue是一个阻塞队列,拥有阻塞队列的固有特性。

4 内部类


    static class Node<E> {
        E item;

        Node<E> next;

        Node(E x) { item = x; }
    }

链表节点类,用于表示链表的节点和存储节点数据。

5 属性

    //队列的容量
    private final int capacity;

    //队列中的当前元素数量
    private final AtomicInteger count = new AtomicInteger();

    //队列的头节点,头节点的数据为null
    transient Node<E> head;

    //队列的尾节点,尾节点的下一个节点为空
    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();

从上面的属性我们可以看出,与ArrayBlockingQueue相比,这里将生产者和消费者分开加锁,这样可以保证再高并发的情况下,生产者和消费者不相互影响,从而提高并发性。

6 构造函数

针对构造函数,我们还是来查看一下比较核心的函数。

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

可以看出这个构造函数做的事比较简单,就初始化了队列大小,并设置了头尾节点,节点数据为null。

7 核心函数

针对LinkedBlockingQueue,我们依然来看一下它的put函数和take函数是怎么实现的。

7.1 put函数

使用put函数可以直接插入数据到队列的尾部,如果队列没有空闲位置用于存放数据,将等待直到线程中断或者有空闲位置。

     public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // Note: convention in all put/take/etc is to preset local var
        // holding count negative to indicate failure unless set.
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            /*
             * Note that count is used in wait guard even though it is
             * not protected by lock. This works because count can
             * only decrease at this point (all other puts are shut
             * out by lock), and we (or some other waiting put) are
             * signalled if it ever changes from capacity. Similarly
             * for all other uses of count in other wait guards.
             */
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }

 

7.2 take函数

8 总结

 

 

### Java JUC AQS 并发编程 抽象队列同步器 使用教程 源码解析 #### 什么是AQS? `AbstractQueuedSynchronizer`(简称AQS),作为Java并发包中的核心组件之一,提供了用于实现锁和其他同步器的基础框架。它不仅简化了锁和同步工具的创建过程,还提高了这些工具的工作效率[^2]。 #### 类图结构与工作原理 AQS的设计围绕着一个FIFO(先进先出)等待队列展开,该队列由多个节点组成,每个节点代表了一个正在等待获取资源的线程。每当有新的竞争者未能立即获得所需资源时,就会被构造成一个新的节点并加入到这个队列之中;而当现有持有者释放其持有的资源之后,则会从队头开始依次唤醒后续等待者去尝试占有资源[^5]。 #### 同步模式分类 为了适应不同场景下的需求,AQS支持两种主要类型的同步方式——独占式以及共享式: - **独占式**:一次只允许单个线程访问临界区,在这种情况下其他任何试图进入同一区域内的请求都将被迫挂起直到前序操作完成为止; - **共享式**:允许多个读取者同时存在而不互相干扰,只要不存在写入动作发生即可保持一致性和安全性[^3]。 #### 自定义同步器的关键接口 对于想要利用AQS来构建特定行为逻辑的新类型而言,开发者通常需要重载以下几个抽象方法以适配具体的应用环境: - `tryAcquire(int arg)` 和 `tryRelease(int arg)` - `tryAcquireShared(int arg)` 及 `tryReleaseShared(int arg)` - `isHeldExclusively()` 上述函数分别对应于独占/共享模式下对资源的操作控制流程,通过合理地覆盖它们可以轻松打造出满足业务特性要求的各种高级别同步原语[^1]。 ```java public class CustomSync extends AbstractQueuedSynchronizer { protected boolean tryAcquire(int acquires) { // 实现具体的独占式获取逻辑 return super.tryAcquire(acquires); } protected boolean tryRelease(int releases) { // 实现具体的独占式释放逻辑 return super.tryRelease(releases); } } ``` #### 队列管理机制详解 在实际运行过程中,AQS内部维护了一条双向链表形式的数据结构用来存储各个待处理的任务单元。每当新成员到来之时便会调用`enqueue()`方法将其追加至末端位置上形成完整的链条关系网状链接,并且借助CAS指令保证整个插入过程的安全可靠性质不受外界因素影响破坏[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值