多线程基础（六、三）BlockingQueue用法详解之LinkedBlockingQueue

已于 2023-08-16 15:46:59 修改
阅读量2.8k 收藏 20
点赞数 2
分类专栏： Java并发编程 文章标签： java 链表 开发语言
于 2023-06-11 11:45:33 首次发布
原文链接：https://juejin.cn/post/7000515796053000228
版权

1. LinkedBlockingQueue的用法

首先我们先来简单看下LinkedBlockingQueue的用法，下面是一个简单示例：

public static void testLinkedBlockingQueue() {
    // 初始化无界阻塞队列
    LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
    // 入队方法
    queue.add(1);
    queue.offer(2);
    try {
      queue.offer(3, 10, TimeUnit.SECONDS);
      queue.put(4);
    } catch (InterruptedException e) {
      // offer和put方法会抛出InterruptedException，需要捕获
      e.printStackTrace();
    }

    // 出队方法
    Integer x1 = queue.remove(); // x1 = 1
    Integer x2 = queue.poll(); // x2 = 2
    try {
      Integer x3 = queue.poll(10, TimeUnit.SECONDS); // x3 = 3
      Integer x4 = queue.take(); // x4 = 4
    } catch (InterruptedException e) {
      // poll和take方法会抛出InterruptedException异常，需要捕获
      e.printStackTrace();
    }
}

通过上面的示例，LinkedBlockingQueue提供了多个入队和出队方法，不同的方法的实现逻辑有所不同，下面我们一起看下LinkedBlockingQueue的原理吧。

2. LinkedBlockingQueue类定义

2.1 基本类定义

首先我们看一下LinkedBlockingQueue的类定义，UML类图如下：

从类图可以看出，LinkedBlockingQueue实现了BlockingQueue接口，并继承了AbstractQueue类，其代码如下：

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
	
	/** 队列的容量，如果不传则默认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();

}

在LinkedBlockingQueue中定义的变量及其含义如下：

  • capacity：该变量表示队列的容量，设置该值则变为一个有界队列；如果不设置的话默认取值为Integer.MAX_VALUE，也可以认为是无界队列

  • count：当前队列中元素的数量

  • head和last：分别表示链表的头尾节点，其中头结点head不存储元素，head.item = null

  • takeLock和notEmpty：出队的锁以及出队条件

  • putLock和notFull：入队的锁以及入队条件

可以看出与ArrayBlockingQueue不同的是，在LinkedBlockingQueue中，入队和出队分别使用两个锁，两个锁可以分别认为是读写锁和读锁，这里的具体原因在后面会进行详细描述

2.2 链表节点定义

LinkedBlockingQueue是基于链表实现的，所以链表的节点定义如下，在Node<E>节点中分别定义了元素item以及后继节点next。

static class Node<E> {
    E item;

    // 后继节点，
    Node<E> next;

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

2.3 构造方法定义

然后我们再来看一下构造方法定义，在LinkedBlockingQueue中提供了三个构造方法，分别是默认构造方法、指定队列容量的构造方法、基于集合的构造方法；

在构造方法中，需要设置队列的容量，并初始化链表的头尾节点；基于集合的构造方法，会根据输入的集合，构建一个非空的队列。

/**
 * 默认构造方法，队列容量为Integer.MAX_VALUE
 */
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);
}

/**
 * 基于集合构建队列，默认容量为Integer.MAX_VALUE
 */
public LinkedBlockingQueue(Collection<? extends E> c) {
    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();
    }
}

3. LinkedBlockingQueue入队和出队

前面介绍了LinkedBlockingQueue的类的基本信息，包括类定义、变量、构造方法，下面我们就重点看下入队和出队方法。

3.1 链表结构

首先，我们先来温习一下如何基于链表实现队列进行入队和出队操作。在文章深入理解Java系列 | Queue用法详解中，我们介绍了基于LinkedList如何实现双端队列功能，对于LinkedBlockingQueue来说，其链表结构为一个单向链表，其结构如下：

队列的入队直接在链表尾结点进行操作，出队直接在链表头结点进行操作

3.2 入队和出队方法

在前一篇文章 深入理解Java系列 | BlockingQueue用法详解 中，我们知道BlockingQueue主要提供了四类方法，如下表所示，LinkedBlockingQueue实现了BlockingQueue接口，所以其方法也是如下四类。后面我们就重点看下入队和出队方法的实现

方法抛出异常返回特定值阻塞阻塞特定时间
入队add(e)offer(e)put(e)offer(e, time, unit)
出队remove()poll()take()poll(time, unit)
获取队首元素element()peek()不支持不支持

3.3 入队操作put

首先我们来看下阻塞入队方法put(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;
    // 入队锁上锁
    putLock.lockInterruptibly();
    try {
    	// 如果队列中元素的数量等于队列的容量，则阻塞当前线程
        while (count.get() == capacity) {
            notFull.await();
        }
        // 执行入队操作
        enqueue(node);
        // 元素数量增1，返回操作前的数量
        c = count.getAndIncrement();
        // c+1为当前队列的元素，如果小于容量，则唤醒notFull的等待线程，触发继续入队操作
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
    	// 释放锁
        putLock.unlock();
    }
    // c为入队前的元素数量，也就是入队前队列为空，则需要唤醒非空条件notEmpty的等待线程，触发出队操作
    if (c == 0)
        signalNotEmpty();
}

private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
    	// 唤醒出队等待的线程
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}

通过上面的代码，我们可以看出put(e)方法的主要流程如下：

  1. 首先生成待插入节点Node<E> node = new Node<E>(e)
  2. 然后尝试使用putLock上锁：如果当前无其他线程进行入队操作，则上锁成功；如果当前有其他线程进行入队操作，则进行等待，直到加锁成功；
  3. 加锁成功之后，首先进行队列容量的检查：如果元素数量等于队列容量，则无空间插入新元素，那么调用notFull.await()阻塞当前线程（当前线程被加入notFull条件的等待队列中；如果当前线程被唤醒，也需要再次检查是否有空间插入，如果没有还需要继续等待；
  4. 当队列有空间时，则调用enqueue(node)进行入队操作，将新节点node插入到链表中
  5. 入队完成后，对元素数量进行+1操作，并获取入队前的元素数量
  6. 判断当前元素数量小于队列容量时，则调用notFull.signal()唤醒一个等待入队的线程
  7. 释放锁
  8. 最后检查入队前元素数量为0，也就是队列为空时，那么此时队列不为空，则需要唤醒等待出队条件notEmpty的线程，触发出队操作，调用方法signalNotEmpty

到这里我们已经看完了整个put(e)操作的主流程，然后我们再看下enqueue(node)操作的具体逻辑，代码如下：

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

在enqueue(node)操作中，就是将插入节点设置为尾结点的next节点，也就是last.next = node，然后再修改尾结点为新插入的节点，即：last = last.next，完成了入队节点的插入操作。

3.4 入队操作offer

在LinkedBlockingQueue中提供了两个offer重载方法，一个是offer(E e)，另外一个是offer(E e, long timeout, TimeUnit unit)，两者的区别如下：

offer(E e)方法在入队时，如果当前队列有空间则直接入队，没有空间则入队失败，返回false；

offer(E e, long timeout, TimeUnit unit)是带等待时间的阻塞入队方法，有空间直接入队，没有空间则等待特定的时间，如果依然无法入队，则返回false

下面看一下两个方法的具体源码：

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)
                // 此时无剩余时间，则入队失败，返回false
                return false;
            // 队列满则等待nanos时间；如果被唤醒，则返回剩余的等待时间
            // 唤醒后依然需要重新检查队列容量，如果无空间则继续等待
            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;
}

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    // 前置检查：如果队列满则直接返回false
    if (count.get() == capacity)
        return false;
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    // 加锁
    putLock.lock();
    try {
        // 检查队列容量
        if (count.get() < capacity) {
            // 队列有空间，则插入新节点
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        }
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();
    // 返回是否入队成功
    return c >= 0;
}

在上述代码中已经加了相关注释，重点看下判断队列容量的部分，在offer(E e)方法中，只进行一次判断，如果有空间才进行入队操作，队列满则不插入；在offer(E e, long timeout, TimeUnit unit)方法中，是在while循环中进行队列容量判断，当队列容量满时，判断是否到达指定的等待时间，如果未到等待时间则继续等待，到达等待时间则入队失败，返回false。

在插入新节点时，都是调用了enqueue(node)方法，并且插入完成后都进行了notFull和notEmpty条件的判断，尝试唤醒等待中的线程。

3.5 入队操作add

在LinkedBlockingQueue中，由于继承了AbstractQueue类，所以add方法也是使用的AbstractQueue中的定义，代码如下；add方法直接调用了offer(E e)方法，并判断是否入队成功，如果入队失败则抛出IllegalStateException异常。

public boolean add(E e) {
    // 直接调用offer(e)方法进行入队
    if (offer(e))
        // 入队成功：返回true
        return true;
    else
        // 入队失败：抛出异常
        throw new IllegalStateException("Queue full");
}

3.6 出队操作take

OK，前面我们已经了解了四类入队方法的实现，下面我们再来理解四类出队方法就会非常容易了，首先，我们还是先看阻塞出队方法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();
        // 队列元素数量-1，返回
        c = count.getAndDecrement();
        // 出队前队列元素大于1，也就是当前队列还有元素，则唤醒一个等待出队的线程
        if (c > 1)
            notEmpty.signal();
    } finally {
        // 释放锁
        takeLock.unlock();
    }
    // 出队前队列元素等于队列容量，也就是出队后队列不满，则唤醒等待入队的线程
    if (c == capacity)
        signalNotFull();
    return x;
}

private void signalNotFull() {
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        // 唤醒等待入队的线程
        notFull.signal();
    } finally {
        putLock.unlock();
    }
}

通过上面的代码，我们可以看出take()方法的主要流程如下：

  1. 尝试使用takeLock上锁：如果当前无其他线程进行出队操作，则上锁成功；如果当前有其他线程进行出队操作，则进行等待，直到加锁成功；
  2. 加锁成功之后，首先进行队列容量的检查：如果队列为空，则调用notEmpty.await()阻塞当前线程；如果当前线程被唤醒，也需要再次检查队列是否为空，如果为空则继续等待；
  3. 当队列不为空，则调用dequeue()进行出队操作，返回出队元素x；
  4. 出队完成后，对元素数量进行-1操作，并获取出队前的元素数量
  5. 判断当前队列中是否还有元素，如果有则调用notEmpty.signal()唤醒一个等待出队的线程
  6. 释放锁
  7. 最后检查出队前队列是否满的，如果是满的，则出队后队列不满，则需要唤醒等待入队条件notFull的线程，触发入队操作，调用方法signalNotFull

在进行出队操作时，调用dequeue()方法，下面看下该方法的具体实现，代码如下：

private E dequeue() {
    // assert takeLock.isHeldByCurrentThread();
    // assert head.item == null;
    // 当前头结点（头结点不存储数据，第一个元素为head.next）
    Node<E> h = head;
    // 当前队列中第一个元素
    Node<E> first = h.next;
    // 原头结点设置无效
    h.next = h; // help GC
    // 最新的头结点指向第一个元素first
    head = first;
    // 获得第一个元素的值
    E x = first.item;
    // 将第一个元素值设置为null，第一个元素变成头结点
    first.item = null;
    // 返回第一个元素值
    return x;
}

出队示意图如下所示：

3.7 出队操作poll

同样的，LinkedBlockingQueue也提供了两个出队poll方法，一个是poll()，有元素则直接出队，无元素则返回null；另一个是poll(long time, TimeUnit unit)，带等待时间的出队方法，当有元素时直接出队，无元素时则等待特定时间。

两个方法的而具体实现请参考下面代码（代码中已经添加详细注释），这里不再赘述了。

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 {
        // 检查队列容量，未到等待时间则继续等待，到达等待时间则返回null
        while (count.get() == 0) {
            if (nanos <= 0)
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        // 出队操作
        x = dequeue();
        // 队列元素-1
        c = count.getAndDecrement();
        if (c > 1)
            // 队列元素不为空，唤醒等待出队的线程
            notEmpty.signal();
    } finally {
        // 释放锁
        takeLock.unlock();
    }
    if (c == capacity)
        // 队列容量未满，唤醒等待入队的线程
        signalNotFull();
    // 返回出队元素
    return x;
}

public E poll() {
    final AtomicInteger count = this.count;
    // 前置判断，队列元素为空，则返回null
    if (count.get() == 0)
        return null;
    E x = null;
    int c = -1;
    final ReentrantLock takeLock = this.takeLock;
    // 加锁
    takeLock.lock();
    try {
        // 检查队列容量，如果不为空则出队操作，为空则返回null
        if (count.get() > 0) {
            // 出队操作
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                // 队列元素不为空，唤醒等待出队的线程
                notEmpty.signal();
        }
    } finally {
        // 释放锁
        takeLock.unlock();
    }
    if (c == capacity)
        // 队列容量未满，唤醒等待入队的线程
        signalNotFull();
    return x;
}

3.8 出队操作remove

在LinkedBlockingQueue中，remove方法也是直接使用的父类AbstractQueue中的remove方法，代码如下；remove方法直接调用了poll()方法，如果出队成功则返回出队元素，出队失败则抛出NoSuchElementException异常。

public E remove() {
    // 调用poll()方法进行出队
    E x = poll();
    if (x != null)
        // 出队成功：返回出队元素
        return x;
    else
        // 出队失败：抛出异常
        throw new NoSuchElementException();
}

4. 对比ArrayBlockingQueue

在ArrayBlockingQueue中，使用了一个ReentrantLock lock作为入队和出队的锁，并使用两个条件notEmpty和notFull来进行线程间通信。而在 LinkedBlockingQueue中，使用了两个锁putLock和takeLock分别作为入队和出队的锁，同样使用了两个锁的两个条件notFull和notEmpty进行线程间通信。

由于在ArrayBlockingQueue中，入队和出队操作共用了同一个锁，所以两个操作之间会有相互影响；而在LinkedBlockingQueue中，入队和出队操作分别使用不同的锁，则入队和出队互不影响，可以提供队列的操作性能。

明湖起风了
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
主要介绍了Java多线程 BlockingQueue实现生产者消费者模型详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
并发容器--LinkedBlockingQueue
libufan的博客
04-30 637
1、LinkedBlockingQueue数据结构 LinkedBlockingQueue是一种基于单向链表的阻塞队列。其数据结构如下，包含了头结点和尾节点。 2、LinkedBlockingQueue源码分析 类的继承关系 public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializ...
LinkedBlockingQueue 的 常用场景及使用示例
最新发布
CAUC_lin的博客
05-13 483
是 Java 并发包 () 中提供的另一种线程安全的阻塞队列实现。与不同的是，默认情况下是一个无界的队列（尽管也可以设置容量上限），它使用双向链表来存储元素。这使得它在频繁插入和删除的场景下具有较好的性能表现。以下是的一些常用场景及使用示例。
老猿说说-LinkedBlockingQueue
热门推荐
老猿说说专栏
11-19 5万+
引导语 说到队列，大家的反应可能是我从来都没有用过，应该是不重要的 API 吧。如果这么想，那就大错特错了，我们平时使用到的线程池、读写锁、消息队列等等技术和框架，底层原理都是队列，所以我们万万不可轻视队列，队列是很多高级 API 的基础，学好队列，对自己深入 Java 学习非常重要。 本文主要以 LinkedBlockingQueue 队列为例，详细描述一下底层具体的实现。 1 整体架构 LinkedBlockingQueue 中文叫做链表阻塞队列，这个命名很好，从命名上就知道其底层数据结构是链表，并且
2020-08-31-LinkedBlockingQueue详解
weixin_43395106的博客
08-31 1406
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录说明一、解读(1)LinkedBlockQueue(2)节点内部类Node(2)LinkedBlockingQueue的属性(2)LinkedBlockingQueue的构造函数(2)LinkedBlockingQueue的添加方法(2)LinkedBlockingQueue的取出方法获取队列当前及剩余容量 说明 通过阅读源码,了解LinkedBlockQueue的特性,本文基于JDK1.7源码 一、解读 通过查询API对Lin
你真的了解LinkedBlockingQueue的put,add和offer的区别吗
lucasma的博客
02-08 1155
概述 LinkedBlockingQueue的put,add和offer这三个方法功能很相似，都是往队列尾部添加一个元素。既然都是同样的功能，为啥要有有三个方法呢？ 这三个方法的区别在于： put方法添加元素，如果队列已满，会阻塞直到有空间可以放 add方法在添加元素的时候，若超出了度列的长度会直接抛出异常 offer方法添加元素，如果队列已满，直接返回false 索引这三种不同的方法在队列满...
ThreadPoolExecutor使用LinkedBlockingQueue的坑
chouxibo9351的博客
08-24 969
坑的描述 ThreadPoolExecutor threadPool = new ThreadPoolExecutor( 4, // corePoolSize 64, // maximumPoolSize 60L, // keepAliveTime TimeUn...
java 中 阻塞队列BlockingQueue详解及实例
08-30
总结来说，Java中的阻塞队列BlockingQueue是并发编程中的一种高效、线程安全的数据结构，它提供了线程间的同步和通信机制，简化了多线程环境下的编程复杂性。通过选择适当的实现类和使用适当的方法，开发者可以灵活...
Java 多线程与并发(16-26)-JUC集合- BlockingQueue详解.pdf
07-27
理解`BlockingQueue`和`BlockingDeque`的关键在于它们的阻塞特性，这使得它们在多线程环境中的使用既高效又安全。面试时，可能会被问到如何使用它们实现生产者-消费者模型，或者如何在并发环境下解决数据同步问题，...
简单实现BlockingQueue,BlockingQueue源码详解
10-20
这种设计模式极大地提高了多线程环境下的程序效率。 首先，我们来了解一下 BlockingQueue 的基本操作： 1. `offer(E e)`: 尝试将元素插入队列，如果队列已满，则返回false。 2. `put(E e)`: 将元素插入队列，如果...
java并发学习之BlockingQueue实现生产者消费者详解
08-28
"java并发学习之BlockingQueue实现生产者消费者详解" BlockingQueue是Java util.concurrent包下重要的数据结构，提供了线程安全的队列访问方式。在多线程应用中，常用于生产-消费场景。BlockingQueue有多种实现，...
BlockingQueue（阻塞队列）
mocas_wang的博客
09-09 1262
目录 1 简介 2 常用方法 入队 出队 3 BlockingQueue的实现 3.1 ArrayBlockingQueue 3.1.1 put方法 3.1.2 take方法 3.2 LinkedBlockingQueue 3.2.1 put方法 3.2.2 take方法 3.2.3 ArrayBlockingQueue与LinkedBlockingQueue对比 3.3 LinkedBlockingDeque 3.4 PriorityBlockingQueue 3.4.1 p
Java多线程：阻塞队列与等待唤醒机制初探
流楚丶格念的博客
07-16 2031
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。...
Java阻塞队列poll_java阻塞队列之LinkedBlockingQueue
weixin_39735005的博客
02-24 975
LinkedBlockingQueue是BlockingQueue中的其中一个，其实现方式为单向链表，下面看其具体实现。(均为JDK8)一、构造函数在LinkedBlockingQueue中有三个构造函数，如下图，1、LinkedBlockingQueue()这是一个无参的构造函数，其定义如下，publicLinkedBlockingQueue() {this(Integer.MAX_VALUE)...
LinkedBlockingQueue 简单使用
weixin_30624825的博客
12-05 679
简介：LinkedBlockingQueue 是线程安全的实现了先入先出等特性，其中主要用到put和take方法，put方法在队列满的时候会阻塞直到有队列成员被消费，take方法在队列空的时候会阻塞，直到有队列成员被放进来。 1.定义方式-->可自定义长度，不定义长度默认为Integer.MAX_VALUE： (1) final static LinkedBlockingQue...
详细分析Java并发集合LinkedBlockingQueue的用法
lemonrel的博客
10-14 359
数组的长度在创建时就必须确定，如果数组长度小了，那么ArrayBlockingQueue队列很容易就被阻塞，如果数组长度大了，就容易浪费内存。而队列这个数据结构天然适合用链表这个形式，而LinkedBlockingQueue就是使用链表方式实现的阻塞队列。 一、链表实现 1.1 Node内部类 /** * 链表的节点，同时也是通过它来实现一个单向链表 */ static class Nod...
选择排序
weixin_39406672的博客
02-24 180
package com; import java.util.Arrays; /** * 算法--选择排序n个数 * O(n²) */ public class SelectionSort { public static void main(String[] args) throws Exception { int[] a =source(); ...
LinkedBlockingQueue的put,add跟offer的区别
04-28 299
LinkedBlockingQueue的put,add和offer的区别 最近在学习<<Java并发编程实践>>，有很多java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一，顾名思义这是一个阻塞的线程安全的队列，底层应该采用链表实现。 看其API的时候发现，添加元素的方法竟然有三个：add,p...
Java并发编程精讲
09-28
课程会讲解Java中并发相关技术的基础、原理和应用，从线程安全、线程(池)，锁实现和并发容器等高并发Java实现，去深入理解在并发编程中，一些最容易被忽视的点，这些点也是我在多年编程经验中实际用到，对于每个小节小课均会有实际的场景应用为你呈现。同时这些也是面试过程中面试官考察的重点，掌握这些点，面试和工作时，做到心中有货，不慌不乱，能够胜任。
java多线程之线程安全队列LinkedBlockingQueue
05-31
LinkedBlockingQueue是Java多线程中的一个线程安全队列，它实现了BlockingQueue接口，可以用来存储和操作元素。它的特点是可以在队列的两端插入和移除元素，并且线程安全，非常适合多线程环境下的使用。 LinkedBlockingQueue采用链表实现，它的容量大小是可以调整的，但是如果不指定容量大小的话，它的容量大小就是Integer.MAX_VALUE，可以认为是无限大的。 在使用LinkedBlockingQueue时，我们可以通过put()方法向队列中添加元素，take()方法从队列中取出元素。如果队列已满，则put()方法会阻塞，直到队列中有空位；如果队列为空，则take()方法会阻塞，直到队列中有元素。 LinkedBlockingQueue还提供了其他方法，例如offer()方法、poll()方法等，用来向队列中添加和取出元素。 总之，LinkedBlockingQueue是一个非常方便、实用的线程安全队列，可以用于多线程环境下的数据存储和操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值