优先、双端队列-我的基础算法刷题之路（八）

news2025/1/13 2:45:48

在这里插入图片描述

本篇博客旨在整理记录自已对优先队列、双端队列的一些总结，以及刷题的解题思路，同时希望可给小伙伴一些帮助。本人也是算法小白，水平有限，如果文章中有什么错误之处，希望小伙伴们可以在评论区指出来，共勉 💪。
本篇内容接上篇：http://t.csdn.cn/akLoF

文章目录

    • 一、双端队列
      • 1.概述
      • 2.接口定义
      • 3.代码实现
    • 二、优先级队列
      • 1.无序数组实现
      • 2.有序数组实现
      • 3.堆实现
    • 三、阻塞队列
      • 1.单锁实现
      • 2.双锁实现
    • 最后

一、双端队列

1.概述

对比如图：

定义特点
队列一端删除（头）另一端添加（尾）First In First Out
双端队列两端都可以删除、添加
优先队列优先级高者先出队
延时队列根据延时时间确定优先级
并发非阻塞队列队列空或满时不阻塞
并发阻塞队列队列空时删除阻塞、队列满时添加阻塞

注1：

  • Java 中 LinkedList 即为典型双端队列实现，不过它同时实现了Queue 接口，也提供了栈的 push pop等方法

注2：

  • 不同语言，操作双端队列得方法命名有所不同，见下表

    操作JavaJavaScriptC++leetCode641
    尾部插入offerLastpushpush_backinsertLast
    头部插入offerFirstunshiftpush_frontinsertFront
    尾部移除pollLastpoppop_backdeleteLast
    头部移除pollFirstshiftpop_frontdeleteFront
    尾部获取peekLastat(-1)backgetRear
    头部获取peekFirstat(0)frontgetFront
    • 常见的还有enqueue 入队、dequeue 出队

2.接口定义

public interface Deque<E> {

    boolean offerFirst(E e);

    boolean offerLast(E e);

    E pollFirst();

    E pollLast();

    E peekFirst();

    E peekLast();
    
    boolean isEmpty();

    boolean isFull();
}

3.代码实现

链表实现

/**
 * 基于环形链表的双端队列
 * @param <E> 元素类型
 */
public class LinkedListDeque<E> implements Deque<E>, Iterable<E> {

    @Override
    public boolean offerFirst(E e) {
        if (isFull()) {
            return false;
        }
        size++;
        Node<E> a = sentinel;
        Node<E> b = sentinel.next;
        Node<E> offered = new Node<>(a, e, b);
        a.next = offered;
        b.prev = offered;
        return true;
    }

    @Override
    public boolean offerLast(E e) {
        if (isFull()) {
            return false;
        }
        size++;
        Node<E> a = sentinel.prev;
        Node<E> b = sentinel;
        Node<E> offered = new Node<>(a, e, b);
        a.next = offered;
        b.prev = offered;
        return true;
    }

    @Override
    public E pollFirst() {
        if (isEmpty()) {
            return null;
        }
        Node<E> a = sentinel;
        Node<E> polled = sentinel.next;
        Node<E> b = polled.next;
        a.next = b;
        b.prev = a;
        size--;
        return polled.value;
    }

    @Override
    public E pollLast() {
        if (isEmpty()) {
            return null;
        }
        Node<E> polled = sentinel.prev;
        Node<E> a = polled.prev;
        Node<E> b = sentinel;
        a.next = b;
        b.prev = a;
        size--;
        return polled.value;
    }

    @Override
    public E peekFirst() {
        if (isEmpty()) {
            return null;
        }
        return sentinel.next.value;
    }

    @Override
    public E peekLast() {
        if (isEmpty()) {
            return null;
        }
        return sentinel.prev.value;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == capacity;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> p = sentinel.next;
            @Override
            public boolean hasNext() {
                return p != sentinel;
            }

            @Override
            public E next() {
                E value = p.value;
                p = p.next;
                return value;
            }
        };
    }

    static class Node<E> {
        Node<E> prev;
        E value;
        Node<E> next;

        public Node(Node<E> prev, E value, Node<E> next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    Node<E> sentinel = new Node<>(null, null, null);
    int capacity;
    int size;

    public LinkedListDeque(int capacity) {
        sentinel.next = sentinel;
        sentinel.prev = sentinel;
        this.capacity = capacity;
    }
}

数组实现

/**
 * 基于循环数组实现, 特点
 * <ul>
 *     <li>tail 停下来的位置不存储, 会浪费一个位置</li>
 * </ul>
 * @param <E>
 */
public class ArrayDeque1<E> implements Deque<E>, Iterable<E> {

    /*
                    h
            t
        0   1   2   3
        b           a
     */
    @Override
    public boolean offerFirst(E e) {
        if (isFull()) {
            return false;
        }
        head = dec(head, array.length);
        array[head] = e;
        return true;
    }

    @Override
    public boolean offerLast(E e) {
        if (isFull()) {
            return false;
        }
        array[tail] = e;
        tail = inc(tail, array.length);
        return true;
    }

    @Override
    public E pollFirst() {
        if (isEmpty()) {
            return null;
        }
        E e = array[head];
        array[head] = null;
        head = inc(head, array.length);
        return e;
    }

    @Override
    public E pollLast() {
        if (isEmpty()) {
            return null;
        }
        tail = dec(tail, array.length);
        E e = array[tail];
        array[tail] = null;
        return e;
    }

    @Override
    public E peekFirst() {
        if (isEmpty()) {
            return null;
        }
        return array[head];
    }

    @Override
    public E peekLast() {
        if (isEmpty()) {
            return null;
        }
        return array[dec(tail, array.length)];
    }

    @Override
    public boolean isEmpty() {
        return head == tail;
    }

    @Override
    public boolean isFull() {
        if (tail > head) {
            return tail - head == array.length - 1;
        } else if (tail < head) {
            return head - tail == 1;
        } else {
            return false;
        }
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public E next() {
                E e = array[p];
                p = inc(p, array.length);
                return e;
            }
        };
    }

    E[] array;
    int head;
    int tail;

    @SuppressWarnings("unchecked")
    public ArrayDeque1(int capacity) {
        array = (E[]) new Object[capacity + 1];
    }

    static int inc(int i, int length) {
        if (i + 1 >= length) {
            return 0;
        }
        return i + 1;
    }

    static int dec(int i, int length) {
        if (i - 1 < 0) {
            return length - 1;
        }
        return i - 1;
    }
}

数组实现中，如果存储的时基本类型，那么无需考虑内存释放，例如

i7yfnA.png

但如果存储的是引用类型，应当设置该位置得引用为null，以便内存及时释放

i7yyRo.png

二、优先级队列

1.无序数组实现

要点

  1. 入队保持顺序
  2. 出队前找到优先级最高的出队，相当于一次选择排序
public class PriorityQueue1<E extends Priority> implements Queue<E> {

    Priority[] array;
    int size;

    public PriorityQueue1(int capacity) {
        array = new Priority[capacity];
    }

    @Override // O(1)
    public boolean offer(E e) {
        if (isFull()) {
            return false;
        }
        array[size++] = e;
        return true;
    }

    // 返回优先级最高的索引值
    private int selectMax() {
        int max = 0;
        for (int i = 1; i < size; i++) {
            if (array[i].priority() > array[max].priority()) {
                max = i;
            }
        }
        return max;
    }

    @Override // O(n)
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        int max = selectMax();
        E e = (E) array[max];
        remove(max);
        return e;
    }

    private void remove(int index) {
        if (index < size - 1) {
            System.arraycopy(array, index + 1,
                    array, index, size - 1 - index);
        }
        array[--size] = null; // help GC
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        int max = selectMax();
        return (E) array[max];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

2.有序数组实现

要点

  1. 入队后排好序，优先级最高的排列在尾部
  2. 出队只需删除尾部元素即可
public class PriorityQueue2<E extends Priority> implements Queue<E> {

    Priority[] array;
    int size;

    public PriorityQueue2(int capacity) {
        array = new Priority[capacity];
    }

    // O(n)
    @Override
    public boolean offer(E e) {
        if (isFull()) {
            return false;
        }
        insert(e);
        size++;
        return true;
    }

    // 一轮插入排序
    private void insert(E e) {
        int i = size - 1;
        while (i >= 0 && array[i].priority() > e.priority()) {
            array[i + 1] = array[i];
            i--;
        }
        array[i + 1] = e;
    }

    // O(1)
    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E e = (E) array[size - 1];
        array[--size] = null; // help GC
        return e;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E) array[size - 1];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

3.堆实现

计算机科学中，堆是一种基于树的数据结构，通常用完全二叉树实现。堆的特性如下

  • 在大顶堆中，任意节点 C 与它的父节点 P 符合 P . v a l u e ≥ C . v a l u e P.value \geq C.value P.value≥C.value
  • 而小顶堆中，任意节点 C 与它的父节点 P 符合 P . v a l u e ≤ C . v a l u e P.value \leq C.value P.value≤C.value
  • 最顶层的节点（没有父亲）称之为 root 根节点

例1 - 满二叉树（Full Binary Tree）特点：每一层都是填满的

i7y2ck.png

例2 - 完全二叉树（Complete Binary Tree）特点：最后一层可能未填满，靠左对齐

i7y0xw.png

例3 - 大顶堆

i7yklz.png

例4 - 小顶堆

i7yHoL.png

完全二叉树可以使用数组来表示

i7yklz.png

特征

  • 如果从索引 0 开始存储节点数据
    • 节点 i 的父结点为 f l o o r ( ( i − 1 ) / 2 ) floor((i-1)/2) floor((i−1)/2)，当 i > 0 i > 0 i>0时
    • 节点 i 的左子节点为 2 i + 1 2i+1 2i+1，右子节点为 2 i + 2 2i+2 2i+2，当然它们得 < s i z e < size <size
  • 如果从索引 1 开始存储节点数据
    • 节点 i i i 的父结点为 f l o o r ( i / 2 ) floor(i/2) floor(i/2)，当 i > 1 i>1 i>1 时
    • 节点 i i i 的左子节点为 2 i 2i 2i，右子节点为 2 i + 1 2i+1 2i+1，同样得 < s i z e < size <size

代码

public class PriorityQueue4<E extends Priority> implements Queue<E> {

    Priority[] array;
    int size;

    public PriorityQueue4(int capacity) {
        array = new Priority[capacity];
    }

    @Override
    public boolean offer(E offered) {
        if (isFull()) {
            return false;
        }
        int child = size++;
        int parent = (child - 1) / 2;
        while (child > 0 && offered.priority() > array[parent].priority()) {
            array[child] = array[parent];
            child = parent;
            parent = (child - 1) / 2;
        }
        array[child] = offered;
        return true;
    }


    private void swap(int i, int j) {
        Priority t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        swap(0, size - 1);
        size--;
        Priority e = array[size];
        array[size] = null;
        
        shiftDown(0);        
        return (E) e;
    }

    void shiftDown(int parent) {
        int left = 2 * parent + 1;
        int right = left + 1;
        int max = parent;
        if (left < size && array[left].priority() > array[max].priority()) {
            max = left;
        }
        if (right < size && array[right].priority() > array[max].priority()) {
            max = right;
        }
        if (max != parent) {
            swap(max, parent);
            shiftDown(max);
        }
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E) array[0];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

三、阻塞队列

之前的队列在很多场景下都不能很好地工作，例如

  1. 大部分场景要求分离向队列放入（生产者）、从队列拿出（消费者）两个角色、它们得由不同的线程来担当，而之前的实现根本没有考虑线程安全问题
  2. 队列为空，那么在之前的实现里会返回 null，如果就是硬要拿到一个元素呢？只要不断循环尝试
  3. 队列为满，那么再之前的实现里会返回 false，如果就是硬要塞入一个元素呢？只能不断循环尝试

因此我们需要解决的问题有

  1. 用锁保证线程的安全
  2. 用条件变量让等待非空线程与等待不满线程进入等待状态，而不是不断循环尝试，让 CPU 空转

有同学对线程安全还没有足够的认识，下面举一个反例，两个线程都要执行入队操作（几乎在同一时刻）

public class TestThreadUnsafe {
    private final String[] array = new String[10];
    private int tail = 0;

    public void offer(String e) {
        array[tail] = e;
        tail++;
    }

    @Override
    public String toString() {
        return Arrays.toString(array);
    }

    public static void main(String[] args) {
        TestThreadUnsafe queue = new TestThreadUnsafe();
        new Thread(()-> queue.offer("e1"), "t1").start();
        new Thread(()-> queue.offer("e2"), "t2").start();
    }
}

执行的时间序列如下，假设初始状态 tail = 0，在执行过程中由于 CPU 在两个线程之间切换，造成了指令交错。

线程1线程2说明
array[tail]=e1线程1 向 tail 位置加入 e1 这个元素，但还没来得及执行 tail++
array[tail]=e2线程2 向 tail 位置加入 e2 这个元素，覆盖掉了 e1
tail++tail 自增为1
tail++tail 自增为2
最后状态 tail 为 2，数组为 [e2, null, null …]

糟糕的是，由于指令交错的顺序不同，得到的结果不止以上一种，宏观上造成混乱的效果。

1.单锁实现

Java 中要防止代码段交错执行，需要使用锁，有两种选择

  • synchronized 代码块，属于关键字级别提供锁保护，功能少
  • ReentrantLock 类，功能丰富

以 ReentrantLock 为例

ReentrantLock lock = new ReentrantLock();

public void offer(String e) {
    lock.lockInterruptibly();
    try {
        array[tail] = e;
        tail++;
    } finally {
        lock.unlock();
    }
}

只要两个线程执行上段代码时，锁对象是同一个，就能保证 try 块内的代码的执行不会出现指令交错现象，即执行顺序只可能是下面两种情况之一。

线程1线程2说明
lock.lockInterruptibly()t1对锁对象上锁
array[tail]=e1
lock.lockInterruptibly()即使 CPU 切换到线程2，但由于t1已经对该对象上锁，因此线程2卡在这儿进不去
tail++切换回线程1 执行后续代码
lock.unlock()线程1 解锁
array[tail]=e2线程2 此时才能获得锁，执行它的代码
tail++
  • 另一种情况是线程2 先获得锁，线程1 被挡在外面
  • 要明白保护的本质，本例中是保护的是 tail 位置读写的安全

事情还没有完，上面的例子是队列还没有放满的情况，考虑下面的代码（这回锁同时保护了 tail 和 size 的读写安全）

ReentrantLock lock = new ReentrantLock();
int size = 0;

public void offer(String e) {
    lock.lockInterruptibly();
    try {
        if(isFull()) {
            // 满了怎么办?
        }
        array[tail] = e;
        tail++;
        
        size++;
    } finally {
        lock.unlock();
    }
}

private boolean isFull() {
    return size == array.length;
}

之前是返回 false 表示添加失败，前面分析过想达到这么一种效果：

  • 在队列满时，不是立刻返回，而是当前线程进入等待
  • 什么时候队列不满了，再唤醒这个等待的线程，从上次的代码处继续向下运行

ReentrantLock 可以配合条件变量来实现，代码进化为：

ReentrantLock lock = new ReentrantLock();
Condition tailWaits = lock.newCondition(); // 条件变量
int size = 0;

public void offer(String e) {
    lock.lockInterruptibly();
    try {
        while (isFull()) {
            tailWaits.await();	// 当队列满时, 当前线程进入 tailWaits 等待
        }
        array[tail] = e;
        tail++;
        
        size++;
    } finally {
        lock.unlock();
    }
}

private boolean isFull() {
    return size == array.length;
}
  • 条件变量底层也是个队列，用来存储这些需要等待的线程，当队列满了，就会将 offer 线程加入条件队列，并暂时释放锁
  • 将来我们的队列如果不满了（由 poll 线程那边得知）可以调用 tailWaits.signal() 来唤醒 tailWaits 中首个等待的线程，被唤醒的线程会再次抢到锁，从上次 await 处继续向下运行

思考为何要用 while 而不是 if，设队列容量是 3？

操作前offer(4)offer(5)poll()操作后
[1 2 3]队列满，进入tailWaits 等待[1 2 3]
[1 2 3]取走 1，队列不满，唤醒线程[2 3]
[2 3]抢先获得锁，发现不满，放入 5[2 3 5]
[2 3 5]从上次等待处直接向下执行[2 3 5 ?]

关键点：

  • 从 tailWaits 中唤醒的线程，会与新来的 offer 的线程争抢锁，谁能抢到是不一定的，如果后者先抢到，就会导致条件又发生变化
  • 这种情况称之为虚假唤醒，唤醒后应该重新检查条件，看是不是得重新进入等待

最后的实现代码

/**
 * 单锁实现
 * @param <E> 元素类型
 */
public class BlockingQueue1<E> implements BlockingQueue<E> {
    private final E[] array;
    private int head = 0;
    private int tail = 0;
    private int size = 0; // 元素个数

    @SuppressWarnings("all")
    public BlockingQueue1(int capacity) {
        array = (E[]) new Object[capacity];
    }

    ReentrantLock lock = new ReentrantLock();
    Condition tailWaits = lock.newCondition();
    Condition headWaits = lock.newCondition();

    @Override
    public void offer(E e) throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (isFull()) {
                tailWaits.await();
            }
            array[tail] = e;
            if (++tail == array.length) {
                tail = 0;
            }
            size++;
            headWaits.signal();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void offer(E e, long timeout) throws InterruptedException {
        lock.lockInterruptibly();
        try {
            long t = TimeUnit.MILLISECONDS.toNanos(timeout);
            while (isFull()) {
                if (t <= 0) {
                    return;
                }
                t = tailWaits.awaitNanos(t);
            }
            array[tail] = e;
            if (++tail == array.length) {
                tail = 0;
            }
            size++;
            headWaits.signal();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public E poll() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (isEmpty()) {
                headWaits.await();
            }
            E e = array[head];
            array[head] = null; // help GC
            if (++head == array.length) {
                head = 0;
            }
            size--;
            tailWaits.signal();
            return e;
        } finally {
            lock.unlock();
        }
    }

    private boolean isEmpty() {
        return size == 0;
    }

    private boolean isFull() {
        return size == array.length;
    }
}
  • public void offer(E e, long timeout) throws InterruptedException 是带超时的版本，可以只等待一段时间，而不是永久等下去，类似的 poll 也可以做带超时的版本，这个留给大家了。

注意

  • JDK 中 BlockingQueue 接口的方法命名与我的示例有些差异
    • 方法 offer(E e) 是非阻塞的实现，阻塞实现方法为 put(E e)
    • 方法 poll() 是非阻塞的实现，阻塞实现方法为 take()

2.双锁实现

单锁的缺点在于：

  • 生产和消费几乎是不冲突的，唯一冲突的是生产者和消费者它们有可能同时修改 size
  • 冲突的主要是生产者之间：多个 offer 线程修改 tail
  • 冲突的还有消费者之间：多个 poll 线程修改 head

如果希望进一步提高性能，可以用两把锁：

  • 一把锁保护 tail
  • 另一把锁保护 head
ReentrantLock headLock = new ReentrantLock();  // 保护 head 的锁
Condition headWaits = headLock.newCondition(); // 队列空时，需要等待的线程集合

ReentrantLock tailLock = new ReentrantLock();  // 保护 tail 的锁
Condition tailWaits = tailLock.newCondition(); // 队列满时，需要等待的线程集合

先看看 offer 方法的初步实现

@Override
public void offer(E e) throws InterruptedException {
    tailLock.lockInterruptibly();
    try {
        // 队列满等待
        while (isFull()) {
            tailWaits.await();
        }
        
        // 不满则入队
        array[tail] = e;
        if (++tail == array.length) {
            tail = 0;
        }
        
        // 修改 size （有问题）
        size++;
        
    } finally {
        tailLock.unlock();
    }
}

上面代码的缺点是 size 并不受 tailLock 保护，tailLock 与 headLock 是两把不同的锁，并不能实现互斥的效果。因此，size 需要用下面的代码保证原子性。

AtomicInteger size = new AtomicInteger(0);	   // 保护 size 的原子变量

size.getAndIncrement(); // 自增
size.getAndDecrement(); // 自减

代码修改为

@Override
public void offer(E e) throws InterruptedException {
    tailLock.lockInterruptibly();
    try {
        // 队列满等待
        while (isFull()) {
            tailWaits.await();
        }
        
        // 不满则入队
        array[tail] = e;
        if (++tail == array.length) {
            tail = 0;
        }
        
        // 修改 size
        size.getAndIncrement();
        
    } finally {
        tailLock.unlock();
    }
}

对称地，可以写出 poll 方法

@Override
public E poll() throws InterruptedException {
    E e;
    headLock.lockInterruptibly();
    try {
        // 队列空等待
        while (isEmpty()) {
            headWaits.await();
        }
        
        // 不空则出队
        e = array[head];
        if (++head == array.length) {
            head = 0;
        }
        
        // 修改 size
        size.getAndDecrement();
        
    } finally {
        headLock.unlock();
    }
    return e;
}

下面来看一个难题，就是如何通知 headWaits 和 tailWaits 中等待的线程，比如 poll 方法拿走一个元素，通知 tailWaits：我拿走一个，不满了噢，你们可以放了，因此代码改为

@Override
public E poll() throws InterruptedException {
    E e;
    headLock.lockInterruptibly();
    try {
        // 队列空等待
        while (isEmpty()) {
            headWaits.await();
        }
        
        // 不空则出队
        e = array[head];
        if (++head == array.length) {
            head = 0;
        }
        
        // 修改 size
        size.getAndDecrement();
        
        // 通知 tailWaits 不满（有问题）
        tailWaits.signal();
        
    } finally {
        headLock.unlock();
    }
    return e;
}

问题在于要使用这些条件变量的 await()， signal() 等方法需要先获得与之关联的锁，上面的代码若直接运行会出现以下错误：

java.lang.IllegalMonitorStateException

那有同学说，加上锁不就行了吗，于是写出了下面的代码
请添加图片描述

发现什么问题了？两把锁这么嵌套使用，非常容易出现死锁，如下所示
i7A5jV.png

因此得避免嵌套，两段加锁的代码变成了下面平级的样子
i7AS6d.png

性能还可以进一步提升

  1. 代码调整后 offer 并没有同时获取 tailLock 和 headLock 两把锁，因此两次加锁之间会有空隙，这个空隙内可能有其它的 offer 线程添加了更多的元素，那么这些线程都要执行 signal()，通知 poll 线程队列非空吗？

    • 每次调用 signal() 都需要这些 offer 线程先获得 headLock 锁，成本较高，要想法减少 offer 线程获得 headLock 锁的次数
    • 可以加一个条件：当 offer 增加前队列为空，即从 0 变化到不空，才由此 offer 线程来通知 headWaits，其它情况不归它管

  2. 队列从 0 变化到不空，会唤醒一个等待的 poll 线程，这个线程被唤醒后，肯定能拿到 headLock 锁，因此它具备了唤醒 headWaits 上其它 poll 线程的先决条件。如果检查出此时有其它 offer 线程新增了元素（不空，但不是从0变化而来），那么不妨由此 poll 线程来唤醒其它 poll 线程

这个技巧被称之为级联通知（cascading notifies），类似的原因

  1. 在 poll 时队列从满变化到不满，才由此 poll 线程来唤醒一个等待的 offer 线程，目的也是为了减少 poll 线程对 tailLock 上锁次数，剩下等待的 offer 线程由这个 offer 线程间接唤醒

最终的代码为

public class BlockingQueue2<E> implements BlockingQueue<E> {

    private final E[] array;
    private int head = 0;
    private int tail = 0;
    private final AtomicInteger size = new AtomicInteger(0);
    ReentrantLock headLock = new ReentrantLock();
    Condition headWaits = headLock.newCondition();
    ReentrantLock tailLock = new ReentrantLock();
    Condition tailWaits = tailLock.newCondition();

    public BlockingQueue2(int capacity) {
        this.array = (E[]) new Object[capacity];
    }

    @Override
    public void offer(E e) throws InterruptedException {
        int c;
        tailLock.lockInterruptibly();
        try {
            while (isFull()) {
                tailWaits.await();
            }
            array[tail] = e;
            if (++tail == array.length) {
                tail = 0;
            }            
            c = size.getAndIncrement();
            // a. 队列不满, 但不是从满->不满, 由此offer线程唤醒其它offer线程
            if (c + 1 < array.length) {
                tailWaits.signal();
            }
        } finally {
            tailLock.unlock();
        }
        // b. 从0->不空, 由此offer线程唤醒等待的poll线程
        if (c == 0) {
            headLock.lock();
            try {
                headWaits.signal();
            } finally {
                headLock.unlock();
            }
        }
    }

    @Override
    public E poll() throws InterruptedException {
        E e;
        int c;
        headLock.lockInterruptibly();
        try {
            while (isEmpty()) {
                headWaits.await(); 
            }
            e = array[head]; 
            if (++head == array.length) {
                head = 0;
            }
            c = size.getAndDecrement();
            // b. 队列不空, 但不是从0变化到不空，由此poll线程通知其它poll线程
            if (c > 1) {
                headWaits.signal();
            }
        } finally {
            headLock.unlock();
        }
        // a. 从满->不满, 由此poll线程唤醒等待的offer线程
        if (c == array.length) {
            tailLock.lock();
            try {
                tailWaits.signal();
            } finally {
                tailLock.unlock();
            }
        }
        return e;
    }

    private boolean isEmpty() {
        return size.get() == 0;
    }

    private boolean isFull() {
        return size.get() == array.length;
    }

}

最后

对各位小伙伴有帮助的话，希望可以点赞❤️+收藏⭐，谢谢各位大佬~~🙌🙌🙌

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/444245.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Netty 源码解析（下）

Netty 源码解析（下）

接上一篇博客 Netty 源码解析&#xff08;上&#xff09;继续分析 上一篇博客中已经分析了绝大部分 ChannelFuture cf bootstrap.bind(9000).sync(); 这一行代码&#xff0c;当这一行代码运行完时&#xff0c;Netty服务端就已经启动好了&#xff0c;接下来就是接收链接&#x…
阅读更多...
Spring Security OAuth2.0(二)-----简化模式/密码模式/客户端模式/刷新 token

Spring Security OAuth2.0(二)-----简化模式/密码模式/客户端模式/刷新 token

简化模式 代码示例 修改authorization_server授权服务模块 新增“implicit” 和修改回调地址为本次地址 修改第三方应用项目搭建新页面模拟 新建implicit.jsp <% page contentType"text/html;charsetUTF-8" language"java" isELIgnored"fals…
阅读更多...
C++入门篇（二）

C++入门篇（二）

目录 一、引用1.1 什么是引用&#xff1f;1.2 引用的特性1.3 常引用1.4 引用的使用场景1.5 传值和传引用效率比较1.5.1 传值和传引用做参数的性能对比1.5.2 传值和传引用做返回值的性能对比 1.6 引用和指针之间的区别 二、内联函数2.1 什么是内联函数&#xff1f;2.2 内联函数的…
阅读更多...
知识变现海哥｜研究了100个项目，这个才是人生逆袭首选

知识变现海哥｜研究了100个项目，这个才是人生逆袭首选

&#xff08;本文源自公号跟海哥学知识变现&#xff0c;移步公号与100万知识变现/知识付费创业者&#xff0c;一起学知识变现知识付费干货&#xff0c;回‘领书’获取3本电子书&#xff1a;【知识付费秘籍】【知识创业者成长手册】【100个知识付费成功案例】) 经常有人问海哥&a…
阅读更多...
什么是中断向量表？作用是什么？为什么需要偏移？

什么是中断向量表？作用是什么？为什么需要偏移？

一、定义与特点 定义&#xff1a;中断向量表(interrupt vector table)包含中断服务程序地址的特定内存区域&#xff0c;这些服务程序是处理外部硬件中断请求的代码。 特点&#xff1a;这些中断服务程序(函数)在中断向量表中的位置是由半导体厂商定好的&#xff0c;当某个中断…
阅读更多...
ESP32-C2开发板 Homekit烧录教程

ESP32-C2开发板 Homekit烧录教程

准备 1.1硬件ESP32 C2开发板&#xff0c;如图1-1所示 图1-1 ESP32 C2开发板 1.2软件 CozyLife APP可以在各大应用市场搜索下载&#xff0c;也可以扫描二维码下载如图1-2所示 HomeKit flash download tool 烧录工具 esp32c2 homkit演示固件 烧录教程 打开flash_download_to…
阅读更多...
以智求治，MapGIS打造公共安全治理新模式

以智求治，MapGIS打造公共安全治理新模式

随着我国城市人口和规模日益扩大&#xff0c;城市运行系统日趋复杂&#xff0c;各类风险隐患增多且呈现相互叠加、相互耦合态势&#xff0c;各类风险、事故灾害类事件造成的损失严重&#xff0c;公共安全防范压力不断增大。 党的二十大报告中指出&#xff1a;“建立大安全大应…
阅读更多...
【容器化应用程序设计和开发】2.1 容器化基础知识和Docker容器

【容器化应用程序设计和开发】2.1 容器化基础知识和Docker容器

往期回顾&#xff1a; 第一章&#xff1a;【云原生概念和技术】 容器化应用程序设计和开发 2.1 容器化基础知识和Docker容器2.1.1 容器的创建2.1.2 容器的管理 容器化应用程序设计和开发是一种基于容器技术的应用程序设计和开发方法论。它将应用程序拆分为多个小型服务&#x…
阅读更多...
Centos7安装MySQL-5.7.17详细教程

Centos7安装MySQL-5.7.17详细教程

1、MySQL安装包可以在Oracle官网下载 下载链接:https://dev.mysql.com/downloads/mysql/5.7.html 也可以通过wget命令下载 wget http://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-5.7.17-linux-glibc2.5-x86_64.tar.gz 下载完成之后解压tar包 命令&#xff1a;tar -zxvf…
阅读更多...
Smith预估控制器

Smith预估控制器

Smith预估器主要针对存在大滞后的系统，作用延迟和反馈延迟环节的控制，Smith预估器的另一篇文章，请参看下面的博客文章： 博途1200/1500PLC Smith预估器(补偿器)算法实现(FB)_RXXW_Dor的博客-CSDN博客在写这篇文章之前写过一篇"大林控制算法"，大家可以参看下面这…
阅读更多...
一款适合智慧档案馆一体化建设平台的多参数空气质量传感器

一款适合智慧档案馆一体化建设平台的多参数空气质量传感器

智慧档案馆一体化建设平台配件产品/空气质量传感器/空气质量云测仪/空气质量检测仪/空气质量探测器/环境集成传感器 主要检测参数&#xff1a;温度、湿度、粉尘PM2.5/PM10、二氧化碳CO2、甲醛、TVOC等六参数档案库房常用环境参数检测。 安装方式&#xff1a;吸顶式 信号输出&…
阅读更多...
Element table组件动态设置expand展开项以及同时只展开一项

Element table组件动态设置expand展开项以及同时只展开一项

场景一&#xff1a;table表格展开项过多&#xff0c;界面数据太繁杂影响查看。 场景二&#xff1a;Element Table加载的数据发生变化时&#xff0c;会重新渲染界面&#xff0c;之前的展开项会自动关闭&#xff0c;用户需要手动去打开展开项&#xff0c;频繁的手动操作会极大的影…
阅读更多...
Vue系列:在离线环境下部署，CDN无法访问导致vuex.min.js、axios.min.js和vue-router.min.js的cdn地址无法访问

Vue系列:在离线环境下部署，CDN无法访问导致vuex.min.js、axios.min.js和vue-router.min.js的cdn地址无法访问

目录 遇到的问题&#xff1a; 问题分析&#xff1a; 解决方案有以下两种&#xff1a; 遇到的问题&#xff1a; 在客户现场部署程序&#xff0c;是在外网环境的服务器上&#xff0c;部署起来后&#xff0c;发现前端vuex.min.js、axios.min.js和vue-router.min.js无法访问 问题…
阅读更多...
【Python_Scrapy学习笔记（十）】基于Scrapy框架的下载器中间件创建代理IP池

【Python_Scrapy学习笔记（十）】基于Scrapy框架的下载器中间件创建代理IP池

基于Scrapy框架的下载器中间件创建代理IP池 前言 本文中介绍 如何基于 Scrapy 框架的下载器中间件创建代理IP池。 正文 1、添加中间件的流程 在 middlewares.py 中新建 代理IP 中间件类在 settings.py 中添加此下载器中间件&#xff0c;设置优先级并开启 2、基于Scrapy框…
阅读更多...
Node【初识Express框架】

Node【初识Express框架】

文章目录 &#x1f31f;前言&#x1f31f;Express框架&#x1f31f;1.什么是框架&#x1f31f;2.express安装&#x1f31f;3.创建web服务基本遵循之前的四个步骤&#xff1a; &#x1f31f;4.路由&#x1f31f; 由 &#xff1a;请求方式请求路径&#xff08;1&#xff09;get发…
阅读更多...
从传统管理到智慧水务：数字化转型的挑战与机遇

从传统管理到智慧水务：数字化转型的挑战与机遇

概念 智慧水务是指利用互联网、物联网、大数据、人工智能等技术手段&#xff0c;将智能化、信息化、互联网等技术与水务领域相结合&#xff0c;通过感知、传输、处理水质、水量、水价等数据信息&#xff0c;对水资源进行全面监测、综合管理、智能调度和优化配置的智能化水务系…
阅读更多...
电商平台商品数据爬虫分析（test阶段可对接测试）

电商平台商品数据爬虫分析（test阶段可对接测试）

1.简单说明 京东&#xff0c;淘宝&#xff0c;天猫&#xff0c;&#xff0c;淘特&#xff0c;拼多多&#xff0c;阿里巴巴&#xff0c;1688&#xff0c;抖音&#xff0c;苏宁&#xff0c;亚马逊中国 &#xff0c;lazada&#xff0c;速卖通等全球50多个知名平台抓取数据&#x…
阅读更多...
蓝牙耳机哪个品牌音质好？300到400的蓝牙耳机推荐

蓝牙耳机哪个品牌音质好？300到400的蓝牙耳机推荐

不知道从什么时候开始&#xff0c;越来越喜欢安静和独处&#xff0c;去外面闲逛也总是佩戴上蓝牙耳机&#xff0c;享受音乐带来的美妙&#xff01;蓝牙耳机便利性也让很多小伙伴开始选择&#xff0c;出门在外&#xff0c;背包里面永远装着蓝牙耳机&#xff0c;以备不时之需&…
阅读更多...
CANoe使用记录（二）：Trace界面介绍

CANoe使用记录（二）：Trace界面介绍

目录 1、概述 2、Trace界面介绍 2.1、右键配置 2.2、显示Title信息 2.3、改变窗口颜色 2.4、详细视图 2.5、静态视图 2.6、差异窗口 2.7、预过滤器 2.8、过滤分析 3.9、保存报文 3.10、其他类型简述 1、概述 Trace界面用于监控报文的界面&#xff0c;此界面包含很…
阅读更多...
缓存优化---环境搭建

缓存优化---环境搭建

缓存优化 为什么要使用redis缓存&#xff1f; 问题说明 用户数量多&#xff0c;系统访问大&#xff0c;频繁访问数据库&#xff0c;系统性能下降&#xff0c;用户体验差 环境搭建 maven坐标 在项目中的pom.xml文件中导入spring data redis的maven坐标&#xff1a; <depen…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023