【Java数据结构及算法实战】系列010：Java队列04——链表实现的阻塞队列LinkedBlockingQueue

本文主要是介绍【Java数据结构及算法实战】系列010：Java队列04——链表实现的阻塞队列LinkedBlockingQueue，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

LinkedBlockingQueue是一种基于链表实现的可选边界的阻塞队列，该队列排序元素FIFO。队列的队首是在该队列上停留时间最长的元素，队列的队尾是在该队列上停留最短时间的元素。在队列尾部插入新的元素，队列检索操作在队列的头部获取元素。

在大多数并发应用程序中，基于链表实现的队列通常具有比基于数组实现的队列更高的吞吐量，但性能上未必占优势。

LinkedBlockingQueue在初始化时可以指定容量也可以不指定容量。当初始化LinkedBlockingQueue指定容量时，是有界队列；当初始化LinkedBlockingQueue未指定容量时，其内部会以Integer.MAX_VALUE值作为容量。当然，因为Integer.MAX_VALUE值非常大，近似无限大，因此LinkedBlockingQueue未指定容量时也可以近似认为是无界队列。

为防止队列的过度的扩展，建议在LinkedBlockingQueue初始化时指定容量。LinkedBlockingQueue内部的链接节点在每次入队元素时动态创建，除非这会使队列超过容量。

LinkedBlockingQueue类及其迭代器实现了Collection和Iterator接口的所有可选方法。LinkedBlockingQueue是Java Collections Framework的一个成员。

1.   LinkedBlockingQueue的声明

LinkedBlockingQueue的接口和继承关系如下

public class LinkedBlockingQueue<E> extends AbstractQueue<E>

        implements BlockingQueue<E>, java.io.Serializable {

   …

}

完整的接口继承关系如下图所示。

从上述代码可以看出，LinkedBlockingQueue既实现了BlockingQueue<E>和java.io.Serializable接口，又继承了java.util.AbstractQueue<E>。其中，AbstractQueue是Queue接口的抽象类，此处不再赘述。

2.   LinkedBlockingQueue的成员变量和构造函数

以下是LinkedBlockingQueue的构造函数和成员变量。

    // 容量

    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;

    // 用于锁住take、poll等操作

    private final ReentrantLock takeLock = new ReentrantLock();

    // 队列非空，唤醒消费者

    private final Condition notEmpty = takeLock.newCondition();

    // 用于锁住put、offer等操作

    private final ReentrantLock putLock = new ReentrantLock();

    // 队列非满，唤醒生产者

private final Condition notFull = putLock.newCondition();

public LinkedBlockingQueue() {

        this(Integer.MAX_VALUE);

    }

    public LinkedBlockingQueue(int capacity) {

        if (capacity <= 0) throw new IllegalArgumentException();

        this.capacity = capacity;

        last = head = new Node<E>(null);

    }

    public LinkedBlockingQueue(Collection<? extends E> c) {

        this(Integer.MAX_VALUE);

        final ReentrantLock putLock = this.putLock;

        putLock.lock(); // 只锁可见，不互斥

        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();

        }

}

从上述代码可以看出，构造函数有三种。构造函数中的参数含义如下

l capacity用于设置队列容量。该参数是可选的，如果未设置，则取Integer.MAX_VALUE值作为容量

l c用于设置最初包含给定集合的元素，按集合迭代器的遍历顺序添加

类成员last和head分别指代链表的尾结点和头结点。链表中的结点用Node类型表示，代码如下：

static class Node<E> {

        E item;

        /**

         * next有以下三种场景:

         * - 真正的后继结点

         * - 当前结点是头结点，则后继结点是head.next

         * - 值为null，表示当前结点是尾结点，没有后继结点

         */

        Node<E> next;

        Node(E x) { item = x; }

}

访问策略是通过ReentrantLock来实现的。通过两个加锁条件notEmpty、notFull来实现并发控制。与ArrayBlockingQueue所不同的是，LinkedBlockingQueue使用了takeLock和putLock两把锁来分别锁住出队操作和入队操作。

count用于记录当前队列里面的元素个数。

3.   LinkedBlockingQueue的核心方法

以下对LinkedBlockingQueue常用核心方法的实现原理进行解释。

3.1.     offer(e)

执行offer(e)方法后有两种结果

l 队列未满时，返回 true

l 队列满时，返回 false

LinkedBlockingQueue的offer (e)方法源码如下：

public boolean offer(E e) {

        if (e == null) throw new NullPointerException(); // 判空

        final AtomicInteger count = this.count;

        if (count.get() == capacity)

            return false;

        final int c;

        final Node<E> node = new Node<E>(e);

        final ReentrantLock putLock = this.putLock;

        putLock.lock(); // 加锁

        try {

            if (count.get() == capacity)

                return false;

            enqueue(node); // 入队

            c = count.getAndIncrement();

            if (c + 1 < capacity)

                notFull.signal(); // 标识当前队列非满

        } finally {

            putLock.unlock(); // 解锁

        }

        if (c == 0)

            signalNotEmpty(); // 标识当前队列已经是非空

        return true;

    }

从上面代码可以看出，执行offer(e)方法时，分为以下几个步骤：

l 判断待入队的元素e是否为null。为null则抛出NullPointerException异常。

l 判断count是否超过了容量的限制，如果是则证明队列已经满了，直接返回false。

l 为了确保并发操作的安全先做了加锁处理。

l 再次判断count是否超过了容量的限制，如果是则证明队列已经满了，直接返回false；否则将元素e做入队处理，并返回true。

l 解锁。

l c是元素e入队前队列中的元素个数。如果是0，则说明之前的队列是空的，还需要执行signalNotEmpty()方法来标识当前队列已经是非空了。

enqueue(node)方法代码如下：

private void enqueue(Node<E> node) {

        last = last.next = node;

    }

enqueue(node)方法就在链表的尾部插入数据元素。

signalNotEmpty()方法代码如下：

private void signalNotEmpty() {

        final ReentrantLock takeLock = this.takeLock;

        takeLock.lock();

        try {

            notEmpty.signal();

        } finally {

            takeLock.unlock();

        }

    }

思考：细心的读者可能会发现，在offer (e)方法方法中做了两次判断count是否超过了容量的限制。那么为什么要判断两次呢？

3.2.     put(e)

执行put(e)方法后有两种结果：

•

l 队列未满时，直接插入没有返回值

l 队列满时，会阻塞等待，一直等到队列未满时再插入

LinkedBlockingQueue的put(e)方法源码如下：

public void put(E e) throws InterruptedException {

        if (e == null) throw new NullPointerException();

        final int c;

        final Node<E> node = new Node<E>(e);

        final ReentrantLock putLock = this.putLock;

        final AtomicInteger count = this.count;

        putLock.lockInterruptibly(); // 获取锁

        try {

            while (count.get() == capacity) {

                notFull.await(); // 使线程等待

            }

            enqueue(node);

            c = count.getAndIncrement();

            if (c + 1 < capacity)

                notFull.signal(); // 标识当前队列非满

        } finally {

            putLock.unlock(); // 解锁

        }

        if (c == 0)

            signalNotEmpty(); // 标识当前队列已经是非空

}

从上面代码可以看出，put(e)方法的实现，分为以下几个步骤：

l 先是要获取锁。

l 而后判断count是否等于容量，如果是则证明队列已经满了，就等待；否则执行enqueue(e)方法做元素的入队。

l 解锁。

l c是元素e入队前队列中的元素个数。如果是0，则说明之前的队列是空的，还需要执行signalNotEmpty()方法来标识当前队列已经是非空了。

3.3.     offer(e,time,unit)

offer(e,time,unit)方法与offer(e)方法不同之处在于，前者加入了等待机制。设定等待的时间，如果在指定时间内还不能往队列中插入数据则返回false。执行offer(e,time,unit)方法有两种结果：

•

l 队列未满时，返回 true

l 队列满时，会阻塞等待，如果在指定时间内还不能往队列中插入数据则返回 false

LinkedBlockingQueue的offer(e,time,unit)方法源码如下：

public boolean offer(E e, long timeout, TimeUnit unit)

        throws InterruptedException {

        if (e == null) throw new NullPointerException();

        long nanos = unit.toNanos(timeout);

        final int c;

        final ReentrantLock putLock = this.putLock;

        final AtomicInteger count = this.count;

        putLock.lockInterruptibly(); // 获取锁

        try {

            while (count.get() == capacity) {

                if (nanos <= 0L)

                    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;

}

从上面代码可以看出，offer(e,time,unit)方法的实现，分为以下几个步骤：

l 先是要获取锁。

l 而后判断count是否等于容量，如果是则证明队列已经满了，就等待；否则执行enqueue(e)方法做元素的入队。

l 解锁。

l c是元素e入队前队列中的元素个数。如果是0，则说明之前的队列是空的，还需要执行signalNotEmpty()方法来标识当前队列已经是非空了。

3.4.     add(e)

执行add(e)方法后有两种结果

l 队列未满时，返回 true

l 队列满时，则抛出异常

ArrayBlockingQueue的add(e)方法源码如下：

    public boolean add(E e) {

        return super.add(e);

    }

从上面代码可以看出，add(e)方法的实现，直接是调用了父类AbstractQueue的add(e)方法。而AbstractQueue的add(e)方法源码如下：

public boolean add(E e) {

        if (offer(e))

            return true;

        else

            throw new IllegalStateException("Queue full");

}

从上面代码可以看出，add(e)方法又调用了offer(e)方法。offer(e)方法此处不再赘述。

3.5.     poll ()

执行poll ()方法后有两种结果：

l 队列不为空时，返回队首值并移除

l 队列为空时，返回 null

LinkedBlockingQueue的poll ()方法源码如下：

public E poll() {

        final AtomicInteger count = this.count;

        if (count.get() == 0)

            return null;

        final E x;

        final int c;

        final ReentrantLock takeLock = this.takeLock;

        takeLock.lock(); // 加锁

        try {

            if (count.get() == 0)

                return null;

            x = dequeue(); // 出队

            c = count.getAndDecrement();

            if (c > 1)

                notEmpty.signal(); // 标识当前队列非空

        } finally {

            takeLock.unlock(); // 解锁

        }

        if (c == capacity)

            signalNotFull(); // 标识当前队列已经是非满

        return x;

    }

从上面代码可以看出，执行poll()方法时，分为以下几个步骤：

l 先是判断count是否等于0，如果等于0则证明队列为空，直接返回null。

l 为了确保并发操作的安全先做了加锁处理。

l 再次判断count是否等于0，如果等于0则证明队列为空，直接返回null；否则执行dequeue()方法做元素的出队。

l 解锁。

l c是元素e入队前队列中的元素个数。如果是等于队列的容量，则说明之前的队列是满的，还需要执行signalNotFull ()方法来标识当前队列已经是非满了。

dequeue()方法源码如下：

private E dequeue() {

        Node<E> h = head;

        Node<E> first = h.next;

        h.next = h; // 利于GC

        head = first;

        E x = first.item;

        first.item = null;

        return x;

}

上面代码比较简单，就是移除链表的头结点。

3.6.     take()

执行take()方法后有两种结果：

l 队列不为空时，返回队首值并移除

l 队列为空时，会阻塞等待，一直等到队列不为空时再返回队首值

LinkedBlockingQueue的take ()方法源码如下：

public E take() throws InterruptedException {

        final E x;

        final int c;

        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.signal(); // 标识当前队列非空

        } finally {

            takeLock.unlock(); // 解锁

        }

        if (c == capacity)

            signalNotFull(); // 标识当前队列已经是非满

        return x;

    }

从上面代码可以看出，执行take()方法时，分为以下几个步骤：

l 先是要获取锁。

l 而后判断count是否等于0，如果等于0则证明队列为空，会阻塞等待；否则执行dequeue()方法做元素的出队。

l 解锁。

l c是元素e入队前队列中的元素个数。如果是等于队列的容量，则说明之前的队列是满的，还需要执行signalNotFull ()方法来标识当前队列已经是非满了。

dequeue()和signalNotFull ()方法此处不再赘述。

3.7.     poll(time,unit)

poll(time,unit)方法与poll()方法不同之处在于，前者加入了等待机制。设定等待的时间，如果在指定时间内队列还为空，则返回null。执行poll(time,unit)方法后有两种结果：

l 队列不为空时，返回队首值并移除

l 队列为空时，会阻塞等待，如果在指定时间内队列还为空则返回 null

LinkedBlockingQueue的poll(time,unit)方法源码如下：

public E poll(long timeout, TimeUnit unit) throws InterruptedException {

        final E x;

        final int c;

        long nanos = unit.toNanos(timeout);

        final AtomicInteger count = this.count;

        final ReentrantLock takeLock = this.takeLock;

        takeLock.lockInterruptibly(); // 获取锁

        try {

            while (count.get() == 0) {

                if (nanos <= 0L)

                    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;

}

从上面代码可以看出，执行poll(time,unit)方法时，分为以下几个步骤：

l 先是要获取锁。

l 而后判断count是否等于0，如果等于0则证明队列为空，会阻塞等待；否则执行dequeue()方法做元素的出队。

l 解锁。

l c是元素e入队前队列中的元素个数。如果是等于队列的容量，则说明之前的队列是满的，还需要执行signalNotFull ()方法来标识当前队列已经是非满了。

dequeue()和signalNotFull ()方法此处不再赘述。

3.8.     remove()

执行remove()方法后有两种结果：

l 队列不为空时，返回队首值并移除

l 队列为空时，抛出异常

LinkedBlockingQueue的remove()方法其实是调用了父类AbstractQueue的remove ()方法，源码如下：

public E remove() {

        E x = poll();

        if (x != null)

            return x;

        else

            throw new NoSuchElementException();

}

从上面代码可以看出，remove()直接调用了poll()方法。如果poll()方法返回结果为null，则抛出NoSuchElementException异常。

poll()方法此处不再赘述。

3.9.     peek()

执行peek()方法后有两种结果：

l 队列不为空时，返回队首值但不移除

l 队列为空时，返回null

peek()方法源码如下：

public E peek() {

        final AtomicInteger count = this.count;

        if (count.get() == 0)

            return null;

        final ReentrantLock takeLock = this.takeLock;

        takeLock.lock(); // 加锁

        try {

            return (count.get() > 0) ? head.next.item : null; // 空则返回null

        } finally {

            takeLock.unlock(); // 解锁

        }

}

从上面代码可以看出，peek()方法比较简单，直接就是获取了链表里面头结点的元素值。

3.10.            element()

执行element()方法后有两种结果：

l 队列不为空时，返回队首值但不移除

l 队列为空时，抛出异常

element()方法其实是调用了父类AbstractQueue的element()方法，源码如下：

public E element() {

        E x = peek();

        if (x != null)

            return x;

        else

            throw new NoSuchElementException();

}

从上面代码可以看出，执行element()方法时，先是获取peek()方法的结果，如果结果是null，则抛出NoSuchElementException异常。

4.   LinkedBlockingQueue的单元测试

LinkedBlockingQueue的单元测试如下：

package com.waylau.java.demo.datastructure;

import static org.junit.jupiter.api.Assertions.assertEquals;

import static org.junit.jupiter.api.Assertions.assertFalse;

import static org.junit.jupiter.api.Assertions.assertNotNull;

import static org.junit.jupiter.api.Assertions.assertNull;

import static org.junit.jupiter.api.Assertions.assertThrows;

import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.NoSuchElementException;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.TimeUnit;

import org.junit.jupiter.api.Test;

/**

* LinkedBlockingQueue Test

*

* @since 1.0.0 2020年5月24日

* @author <a href="https://waylau.com">Way Lau</a>

*/

class LinkedBlockingQueueTests {

    @Test

    void testOffer() {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列未满时，返回 true

        boolean resultNotFull = queue.offer("Java");

        assertTrue(resultNotFull);

        // 测试队列满则，返回 false

        queue.offer("C");

        queue.offer("Python");

        boolean resultFull = queue.offer("C++");

        assertFalse(resultFull);

    }

    @Test

    void testPut() throws InterruptedException {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列未满时，直接插入没有返回值；

        queue.put("Java");

        // 测试队列满则，会阻塞等待，一直等到队列未满时再插入。

        queue.put("C");

        queue.put("Python");

        queue.put("C++"); // 阻塞等待

    }

    @Test

    void testOfferTime() throws InterruptedException {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列未满时，返回 true

        boolean resultNotFull = queue.offer("Java", 5, TimeUnit.SECONDS);

        assertTrue(resultNotFull);

        // 测试队列满则，返回 false

        queue.offer("C");

        queue.offer("Python");

        boolean resultFull = queue.offer("C++", 5, TimeUnit.SECONDS); // 等5秒

        assertFalse(resultFull);

    }

    @Test

    void testAdd() {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列未满时，返回 true

        boolean resultNotFull = queue.add("Java");

        assertTrue(resultNotFull);

        // 测试队列满则抛出异常

        queue.add("C");

        queue.add("Python");

        Throwable excpetion = assertThrows(IllegalStateException.class, () -> {

            queue.add("C++");// 抛异常

        });

        assertEquals("Queue full", excpetion.getMessage());

    }

    @Test

    void testPoll() throws InterruptedException {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列为空时，返回 null

        String resultEmpty = queue.poll();

        assertNull(resultEmpty);

        // 测试队列不为空时，返回队首值并移除

        queue.put("Java");

        queue.put("C");

        queue.put("Python");

        String resultNotEmpty = queue.poll();

        assertEquals("Java", resultNotEmpty);

    }

    @Test

    void testTake() throws InterruptedException {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列不为空时，返回队首值并移除

        queue.put("Java");

        queue.put("C");

        queue.put("Python");

        String resultNotEmpty = queue.take();

        assertEquals("Java", resultNotEmpty);

        // 测试队列为空时，会阻塞等待，一直等到队列不为空时再返回队首值

        queue.clear();

        String resultEmpty = queue.take(); // 阻塞等待

        assertNotNull(resultEmpty);

    }

    @Test

    void testPollTime() throws InterruptedException {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列不为空时，返回队首值并移除

        queue.put("Java");

        queue.put("C");

        queue.put("Python");

        String resultNotEmpty = queue.poll(5, TimeUnit.SECONDS);

        assertEquals("Java", resultNotEmpty);

        // 测试队列为空时，会阻塞等待，如果在指定时间内队列还为空则返回 null

        queue.clear();

        String resultEmpty = queue.poll(5, TimeUnit.SECONDS); // 等待5秒

        assertNull(resultEmpty);

    }

    @Test

    void testRemove() throws InterruptedException {

        // 初始化队列

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列为空时，抛出异常

        Throwable excpetion = assertThrows(NoSuchElementException.class, () -> {

            queue.remove();// 抛异常

        });

        assertEquals(null, excpetion.getMessage());

        // 测试队列不为空时，返回队首值并移除

        queue.put("Java");

        queue.put("C");

        queue.put("Python");

        String resultNotEmpty = queue.remove();

        assertEquals("Java", resultNotEmpty);

}

@Test

    void testPeek() throws InterruptedException {

        // 初始化队列

        Queue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列不为空时，返回队首值并但不移除

        queue.add("Java");

        queue.add("C");

        queue.add("Python");

        String resultNotEmpty = queue.peek();

        assertEquals("Java", resultNotEmpty);

        resultNotEmpty = queue.peek();

        assertEquals("Java", resultNotEmpty);

        resultNotEmpty = queue.peek();

        assertEquals("Java", resultNotEmpty);

        // 测试队列为空时，返回null

        queue.clear();

        String resultEmpty = queue.peek();

        assertNull(resultEmpty);

    }

    @Test

    void testElement() throws InterruptedException {

        // 初始化队列

        Queue<String> queue = new LinkedBlockingQueue<String>(3);

        // 测试队列不为空时，返回队首值并但不移除

        queue.add("Java");

        queue.add("C");

        queue.add("Python");

        String resultNotEmpty = queue.element();

        assertEquals("Java", resultNotEmpty);

        resultNotEmpty = queue.element();

        assertEquals("Java", resultNotEmpty);

        resultNotEmpty = queue.element();

        assertEquals("Java", resultNotEmpty);

        // 测试队列为空时，抛出异常

        queue.clear();

        Throwable excpetion = assertThrows(NoSuchElementException.class, () -> {

            queue.element();// 抛异常

        });

        assertEquals(null, excpetion.getMessage());

    }

}

5.   LinkedBlockingQueue的应用案例

以下是一个生产者-消费者的示例。该示例模拟了1个生产者，2个消费者。当队列满时，则会阻塞生产者生产；当队列空时，则会阻塞消费者消费。

package com.waylau.java.demo.datastructure;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.BlockingQueue;

/**

* LinkedBlockingQueue Demo

*

* @since 1.0.0 2020年5月23日

* @author <a href="https://waylau.com">Way Lau</a>

*/

public class LinkedBlockingQueueDemo {

    public static void main(String[] args) {

        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

        // 1个生产者

        Producer p = new Producer(queue);

        // 2个消费者

        Consumer c1 = new Consumer("c1", queue);

        Consumer c2 = new Consumer("c2", queue);

        // 启动线程

        new Thread(p).start();

        new Thread(c1).start();

        new Thread(c2).start();

    }

}

class Producer implements Runnable {

    private final BlockingQueue<String> queue;

    Producer(BlockingQueue<String> queue) {

        this.queue = queue;

    }

    public void run() {

        try {

            while (true) {

                // 模拟耗时操作

                Thread.sleep(1000L);

                queue.put(produce());

            }

        } catch (InterruptedException ex) {

            ex.printStackTrace();

        }

    }

    String produce() {

        String apple = "apple: " + System.currentTimeMillis();

        System.out.println("produce " + apple);

        return apple;

    }

}

class Consumer implements Runnable {

    private final BlockingQueue<String> queue;

    private final String name;

    Consumer(String name, BlockingQueue<String> queue) {

        this.queue = queue;

        this.name = name;

    }

    public void run() {

        try {

            while (true) {

                // 模拟耗时操作

                Thread.sleep(2000L);

                consume(queue.take());

            }

        } catch (InterruptedException ex) {

            ex.printStackTrace();

        }

    }

    void consume(Object x) {

        System.out.println(this.name + " consume " + x);

    }

}

运行上述程序，输出内容如下：

produce apple: 1590308520134

c1 consume apple: 1590308520134

produce apple: 1590308521135

c2 consume apple: 1590308521135

produce apple: 1590308522142

c1 consume apple: 1590308522142

produce apple: 1590308523147

c2 consume apple: 1590308523147

produce apple: 1590308524156

c1 consume apple: 1590308524156

produce apple: 1590308525157

c2 consume apple: 1590308525157

produce apple: 1590308526157

c1 consume apple: 1590308526157

produce apple: 1590308527157

c2 consume apple: 1590308527157

6.   参考引用

本系列归档至《Java数据结构及算法实战》：https://github.com/waylau/java-data-structures-and-algorithms-in-action
《数据结构和算法基础（Java语言实现）》（柳伟卫著，北京大学出版社出版）：https://item.jd.com/13014179.html

这篇关于【Java数据结构及算法实战】系列010：Java队列04——链表实现的阻塞队列LinkedBlockingQueue的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

【Java数据结构及算法实战】系列010：Java队列04——链表实现的阻塞队列LinkedBlockingQueue

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯