• 集合-LinkedBlockingQueue 源码解析


    问题

    (1)LinkedBlockingQueue的实现方式?

    (2)LinkedBlockingQueue是有界的还是无界的队列?

    (3)LinkedBlockingQueue相比ArrayBlockingQueue有什么改进?

    简介

    LinkedBlockingQueue是java并发包下一个以单链表实现的阻塞队列,它是线程安全的,至于它是不是有界的,请看下面的分析。

    源码分析

    主要属性

    // 容量
    private final int capacity;
    
    // 元素数量
    private final AtomicInteger count = new AtomicInteger();
    
    // 链表头
    transient Node<E> head;
    
    // 链表尾
    private transient Node<E> last;
    
    // take锁
    private final ReentrantLock takeLock = new ReentrantLock();
    
    // notEmpty条件
    // 当队列无元素时,take锁会阻塞在notEmpty条件上,等待其它线程唤醒
    private final Condition notEmpty = takeLock.newCondition();
    
    // 放锁
    private final ReentrantLock putLock = new ReentrantLock();
    
    // notFull条件
    // 当队列满了时,put锁会会阻塞在notFull上,等待其它线程唤醒
    private final Condition notFull = putLock.newCondition();

    (1)capacity,有容量,可以理解为LinkedBlockingQueue是有界队列

    (2)head, last,链表头、链表尾指针

    (3)takeLock,notEmpty,take锁及其对应的条件

    (4)putLock, notFull,put锁及其对应的条件

    (5)入队、出队使用两个不同的锁控制,锁分离,提高效率

    内部类

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

    典型的单链表结构。

    主要构造方法

    public LinkedBlockingQueue() {
        // 如果没传容量,就使用最大int值初始化其容量
        this(Integer.MAX_VALUE);
    }
    
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        // 初始化head和last指针为空值节点
        last = head = new Node<E>(null);
    }

    入队

    入队同样有四个方法,我们这里只分析最重要的一个,put(E e)方法:

    public void put(E e) throws InterruptedException {
        // 不允许null元素
        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;
        // 使用put锁加锁
        putLock.lockInterruptibly();
        try {
            // 如果队列满了,就阻塞在notFull条件上
            // 等待被其它线程唤醒
            while (count.get() == capacity) {
                notFull.await();
            }
            // 队列不满了,就入队
            enqueue(node);
            // 队列长度加1
            c = count.getAndIncrement();
            // 如果现队列长度如果小于容量
            // 就再唤醒一个阻塞在notFull条件上的线程
            // 这里为啥要唤醒一下呢?
            // 因为可能有很多线程阻塞在notFull这个条件上的
            // 而取元素时只有取之前队列是满的才会唤醒notFull
            // 为什么队列满的才唤醒notFull呢?
            // 因为唤醒是需要加putLock的,这是为了减少锁的次数
            // 所以,这里索性在放完元素就检测一下,未满就唤醒其它notFull上的线程
            // 说白了,这也是锁分离带来的代价
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            // 释放锁
            putLock.unlock();
        }
        // 如果原队列长度为0,现在加了一个元素后立即唤醒notEmpty条件
        if (c == 0)
            signalNotEmpty();
    }
    
    private void enqueue(Node<E> node) {
        // 直接加到last后面
        last = last.next = node;
    }    
    
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        // 加take锁
        takeLock.lock();
        try {
            // 唤醒notEmpty条件
            notEmpty.signal();
        } finally {
            // 解锁
            takeLock.unlock();
        }
    }

    (1)使用putLock加锁;

    (2)如果队列满了就阻塞在notFull条件上;

    (3)否则就入队;

    (4)如果入队后元素数量小于容量,唤醒其它阻塞在notFull条件上的线程;

    (5)释放锁;

    (6)如果放元素之前队列长度为0,就唤醒notEmpty条件;

    出队

    出队同样也有四个方法,我们这里只分析最重要的那一个,take()方法:

    public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        // 使用takeLock加锁
        takeLock.lockInterruptibly();
        try {
            // 如果队列无元素,则阻塞在notEmpty条件上
            while (count.get() == 0) {
                notEmpty.await();
            }
            // 否则,出队
            x = dequeue();
            // 获取出队前队列的长度
            c = count.getAndDecrement();
            // 如果取之前队列长度大于1,则唤醒notEmpty
            if (c > 1)
                notEmpty.signal();
        } finally {
            // 释放锁
            takeLock.unlock();
        }
        // 如果取之前队列长度等于容量
        // 则唤醒notFull
        if (c == capacity)
            signalNotFull();
        return x;
    }
    
    private E dequeue() {
        // head节点本身是不存储任何元素的
        // 这里把head删除,并把head下一个节点作为新的值
        // 并把其值置空,返回原来的值
        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;
    }
    
    private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            // 唤醒notFull
            notFull.signal();
        } finally {
            putLock.unlock();
        }
    }

    (1)使用takeLock加锁;

    (2)如果队列空了就阻塞在notEmpty条件上;

    (3)否则就出队;

    (4)如果出队前元素数量大于1,唤醒其它阻塞在notEmpty条件上的线程;

    (5)释放锁;

    (6)如果取元素之前队列长度等于容量,就唤醒notFull条件;

    总结

    (1)LinkedBlockingQueue采用单链表的形式实现;

    (2)LinkedBlockingQueue采用两把锁的锁分离技术实现入队出队互不阻塞;

    (3)LinkedBlockingQueue是有界队列,不传入容量时默认为最大int值;

    彩蛋

    (1)LinkedBlockingQueue与ArrayBlockingQueue对比?

    a)后者入队出队采用一把锁,导致入队出队相互阻塞,效率低下;

    b)前才入队出队采用两把锁,入队出队互不干扰,效率较高;

    c)二者都是有界队列,如果长度相等且出队速度跟不上入队速度,都会导致大量线程阻塞;

    d)前者如果初始化不传入初始容量,则使用最大int值,如果出队速度跟不上入队速度,会导致队列特别长,占用大量内存;

  • 相关阅读:
    golang手动导入github net(https://github.com/golang/net)库到本地(Windows)使用
    lstm例子generate_movies函数分析
    python使用pylab一幅图片画多个图
    python数组array的transpose方法
    python Parallel delayed 示例
    json&pickle数据序列化模块
    html的标签分类————body内标签系列
    html的标签分类————可以上传的数据篇
    不可将布尔值直接与true或者1进行比较
    mock
  • 原文地址:https://www.cnblogs.com/hiramxq/p/13256035.html
Copyright © 2020-2023  润新知