【P说】深入理解Java阻塞队列

最新推荐文章于 2023-06-06 10:55:32 发布
最新推荐文章于 2023-06-06 10:55:32 发布
阅读量139 收藏
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solo_jm/article/details/106277089
版权

简介

阻塞队列是一种队列，一种可以在多线程环境下使用，并且支持阻塞等待的队列。

  1. 当队列满的时候，插入元素的线程被阻塞，直达队列不满。
  2. 队列为空的时候，获取元素的线程被阻塞，直到队列不空。

方法

java的阻塞队列，要实现BlockingQueue接口：

public interface BlockingQueue<E> extends Queue<E> {

    boolean add(E e);

    boolean offer(E e);

    void put(E e) throws InterruptedException;

    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    E take() throws InterruptedException;

    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    int remainingCapacity();

    boolean remove(Object o);

    public boolean contains(Object o);

    int drainTo(Collection<? super E> c);

    int drainTo(Collection<? super E> c, int maxElements);
}

常用方法的作用理解:

方法抛出异常返回值一直阻塞超时退出
插入方法addofferputOffer(time)
移除方法removepolltakePoll(time)
检查方法elementpeekN/AN/A
  • 抛出异常：当队列满时，如果再往队列里插入元素，会抛出IllegalStateException（“Queuefull”）异常。当队列空时，从队列里获取元素会抛出NoSuchElementException异常。
  • 返回特殊值：当往队列插入元素时，会返回元素是否插入成功，成功返回true。如果是移除方法，则是从队列里取出一个元素，如果没有则返回null。
  • 一直阻塞：当阻塞队列满时，如果生产者线程往队列里put元素，队列会一直阻塞生产者线程，直到队列可用或者响应中断退出。当队列空时，如果消费者线程从队列里take元素，队列会阻塞住消费者线程，直到队列不为空。
  • 超时退出：当阻塞队列满时，如果生产者线程往队列里插入元素，队列会阻塞生产者线程一段时间，如果超过了指定的时间，生产者线程就会退出。

Java中的几种阻塞队列

  1. ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。
    按照先进先出原则，要求设定初始大小
  2. LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。
    按照先进先出原则，可以不设定初始大小，Integer.Max_Value
    eq:ArrayBlockingQueue和LinkedBlockingQueue不同：
  • 锁上面：ArrayBlockingQueue只有一个锁，LinkedBlockingQueue用了两个锁（插入和读取用了两个锁），
  • 实现上：ArrayBlockingQueue直接插入元素，LinkedBlockingQueue需要转换(转为链表节点)。
  1. PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。
    默认情况下，按照自然顺序，要么实现compareTo()方法，指定构造参数Comparator
  2. DelayQueue：一个使用优先级队列实现的无界阻塞队列。
    支持延时获取的元素的阻塞队列，元素必须要实现Delayed接口。适用场景：实现自己的缓存系统，订单到期，限时支付等等。
  3. SynchronousQueue：一个不存储元素的阻塞队列。
    每一个put操作都要等待一个take操作
  4. LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
    transfer()，必须要消费者消费了以后方法才会返回，tryTransfer()无论消费者是否接收，方法都立即返回。
  5. LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
    可以从队列的头和尾都可以插入和移除元素，实现工作密取，方法名带了First对头部操作，带了last从尾部操作，另外：add=addLast; remove=removeFirst; take=takeFirst

使用

ArrayBlockingQueue

本例生产者两秒中发送一条消息，而消费者一秒钟就会测试获取一条消息，因此消费者阻塞等待。

public class BlockingQueue {
    //生产者线程
    static class SCZThread extends Thread {

        private ArrayBlockingQueue<String> arrayBlockingQueue;

        private int count = 0;

        SCZThread(ArrayBlockingQueue<String> arrayBlockingQueue) {
            this.arrayBlockingQueue = arrayBlockingQueue;
        }

        @Override
        public void run() {
            //生产者每隔2秒中就发送一条消息
            while (true) {
                try {
                    Thread.sleep(2000);
                    //ArrayBlockingQueue的put在插入时，如果阻塞队列已经满了，就会阻塞，因此可能会抛出InterruptedException的中断异常
                    arrayBlockingQueue.put("来着生产者的第" + (++count) + "条消息");
                    System.out.println("发送了生产者的第" + count + "条消息");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //消费者线程
    static class XFZThread extends Thread {

        private ArrayBlockingQueue<String> arrayBlockingQueue;

        private int count = 0;

        XFZThread(ArrayBlockingQueue<String> arrayBlockingQueue) {
            this.arrayBlockingQueue = arrayBlockingQueue;
        }

        @Override
        public void run() {
            //生产者每隔1秒中就等待就收消息
            while (true) {
                try {
                    Thread.sleep(1000);
                    System.out.println("等待接收消息");
                    //ArrayBlockingQueue的take在获取时，如果阻塞队列是空的，就会阻塞，因此可能会抛出InterruptedException的中断异常
                    String message = arrayBlockingQueue.take();
                    System.out.println("收到生产者发送的消息" + message);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        //必须指定容量
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(10);
        new SCZThread(arrayBlockingQueue).start();
        new XFZThread(arrayBlockingQueue).start();
    }
}

结果：
在这里插入图片描述

DelayQueue

DelayQueue可以放入消息时设置过期时间，过期时间到了，就会弹出，被消费者拿到。这个队列可以用来处理需要过期时间的场景，比如redis中的key过期，订单过期。
由于放进DelayQueue的数据需要实现Delay接口，所以要先对数据进行封装。

public class ItemVo<T> implements Delayed{
	
	private long activeTime;//到期时间，单位毫秒
	private T date;
	
	//activeTime是个过期时刻
	public ItemVo(long activeTime, T date) {
		super();
		//传入的时间是毫秒，先转换为纳秒，activeTime保存的是过期时刻，因此还要加上当前系统时间
		this.activeTime = TimeUnit.NANOSECONDS.convert(activeTime, 
				TimeUnit.MILLISECONDS)+System.nanoTime();//将传入的时长转换为超时的时刻
		this.date = date;
	}
	
	public long getActiveTime() {
		return activeTime;
	}

	public T getDate() {
		return date;
	}

	//按照剩余时间排序
	@Override
	public int compareTo(Delayed o) {
		long d = getDelay(TimeUnit.NANOSECONDS)-o.getDelay(TimeUnit.NANOSECONDS);
		return (d==0)?0:((d>0)?1:-1);
	}

	//返回元素的剩余时间
	@Override
	public long getDelay(TimeUnit unit) {
		long d = unit.convert(this.activeTime-System.nanoTime(),
				TimeUnit.NANOSECONDS);
		return d;
	}
}

消费者：

public class FetchOrder implements Runnable {
	
	private DelayQueue<ItemVo<Order>> queue;
	
	public FetchOrder(DelayQueue<ItemVo<Order>> queue) {
		super();
		this.queue = queue;
	}	

	@Override
	public void run() {
		while(true) {
			try {
				ItemVo<Order> item = queue.take();
				Order order = (Order)item.getDate();
				System.out.println("get from queue:"+order.getOrderNo());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}	
}

生产者：

public class PutOrder implements Runnable {
	
	private DelayQueue<ItemVo<Order>> queue;
	
	public PutOrder(DelayQueue<ItemVo<Order>> queue) {
		super();
		this.queue = queue;
	}

	@Override
	public void run() {
		
		//5秒到期
		Order ordeTb = new Order("Tb12345",366);
		ItemVo<Order> itemTb = new ItemVo<Order>(5000,ordeTb);
		queue.offer(itemTb);
		System.out.println("订单5秒后到期："+ordeTb.getOrderNo());
		
		//8秒到期
		Order ordeJd = new Order("Jd54321",366);
		ItemVo<Order> itemJd = new ItemVo<Order>(8000,ordeJd);
		queue.offer(itemJd);
		System.out.println("订单8秒后到期："+ordeJd.getOrderNo());		
		
	}	
}

源码分析

ArrayBlockingQueue

成员变量

//保存消息的数组，初始化时候需要指定该数组的长度
final Object[] items;

//下次插入数据时的下标位置
int takeIndex;

//下次获取数据时的下标位置
int putIndex;

//当前保存的消息数量
int count;

//锁
final ReentrantLock lock;

//数组不为空时的通知Condition 
private final Condition notEmpty;

//数组还没满时的通知Condition 
private final Condition notFull;

返回值插入offer

往队列加入一个消息，加入成功返回true，失败返回false。

public boolean offer(E e) {
    checkNotNull(e); //参数校验
    final ReentrantLock lock = this.lock;
    lock.lock(); //拿锁
    try {
        if (count == items.length) //队列已经满了，返回false
            return false;
        else {
            enqueue(e); //队列没有满，调用enqueue入队
            return true;
        }
    } finally {
        lock.unlock(); //释放锁
    }
}

private void enqueue(E x) {
    final Object[] items = this.items;
    items[putIndex] = x; //putIndex插入位置下标
    if (++putIndex == items.length) //判断是否已经超出最大下标，一个循环
        putIndex = 0;
    count++; //保存的消息加一
    notEmpty.signal(); //notEmpty Condition通知正在等待获取消息的线程
}

抛出异常插入add

插入失败时返回IllegalStateException(“Queue full”)，成功返回true

public boolean add(E e) {
    return super.add(e); //调用了父类的add
}

//父类的add
public boolean add(E e) {
    if (offer(e)) //调用了offer方法
        return true;
    else
        throw new IllegalStateException("Queue full"); //抛出异常
}

一直阻塞插入put

插入失败时阻塞，直到成功插入，不会超时，如果一直失败那么就一直阻塞。

public void put(E e) throws InterruptedException {
    checkNotNull(e); //校验参数
    final ReentrantLock lock = this.lock; 
    lock.lockInterruptibly(); //获取锁，获取过程可以被中断
    try {
        while (count == items.length) //队列已经满了，插入失败
            notFull.await(); //等待不满通知
        enqueue(e); //进队
    } finally {
        lock.unlock(); //释放锁
    }
}

超时退出插入Offer(time)

队列满时，插入阻塞，超过超时时间则返回false。

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

    checkNotNull(e);
    long nanos = unit.toNanos(timeout);  //转为纳秒
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly(); //获得锁
    try {
        while (count == items.length) { //队列已经满了
            if (nanos <= 0) //判断是否过期
                return false;
            nanos = notFull.awaitNanos(nanos); //阻塞，该地方被唤醒要两种情况，一种时队列没满时，被通知，一种时超时。如果是超时，这是会这一次执行while条件进入并被判断为过期，返回false
        }
        enqueue(e);
        return true;
    } finally {
        lock.unlock(); //释放锁
    }
}

阻塞获取poll

尝试从队列中获取消息，然后获取不到就返回null

public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock(); //拿锁
    try {
        return (count == 0) ? null : dequeue(); //队列为空时，返回null，否则调用dequeue方法
    } finally {
        lock.unlock(); //解锁
    }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex]; //拿到对应下标的消息
    items[takeIndex] = null;  //移除
    if (++takeIndex == items.length) 
        takeIndex = 0;
    count--;  //队列消息减一
    if (itrs != null)
        itrs.elementDequeued(); 
    notFull.signal(); //发出队列没满的通知
    return x;
}

阻塞获取take

队列中没有消息时，获取会阻塞

public E take() throws InterruptedException {
     final ReentrantLock lock = this.lock;
     lock.lockInterruptibly();
     try {
         while (count == 0)
             notEmpty.await(); //阻塞，等待非空通知
         return dequeue();
     } finally {
         lock.unlock();
     }
 }

超时获得poll(long timeout, TimeUnit unit)

获取超时返回null

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try { 
        while (count == 0) { //条件判断
            if (nanos <= 0)  //过期判断
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        return dequeue();
    } finally {
        lock.unlock();
    }
}

LinkedBlockingQueue

LinkedBlockingQueue的实现与ArrayBlockingQueue基本一致，LinkedBlockingQueue的内部使用链表存储消息，所以放进队列中的消息会被先封装成为Node。

static class Node<E> {
    E item;
    
    Node<E> next;

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

ArrayBlockingQueue只用了一个锁，无论时获取还是插入，这样对效率是有影响的，获取时不能插入，插入时不能获取。LinkedBlockingQueue使用两把锁，在效率上是有提升的。

/** Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();

/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();

/** Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();

/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition();

DelayQueue

DelayQueue最特殊的地方就是可以通过take获得到期的消息

public E take() throws InterruptedException {
      final ReentrantLock lock = this.lock;
      lock.lockInterruptibly(); //上锁
      try {
          for (;;) {
              E first = q.peek(); //队列头消息
              if (first == null) //队列时空的
                  available.await();  //等待有消息通知
              else {
                  long delay = first.getDelay(NANOSECONDS); //拿到剩余的过期时间
                  if (delay <= 0) //已经过期，直接出队
                      return q.poll();
                  first = null; //线程等待的时候不要持有对头对象
                  if (leader != null) //leader表示已经有其他线程先调用了take方法，所以当前线程要先进行等待
                      available.await(); //available表示当没有其他线程在等待时的通知，因为一次只通知一个线程，当通知到这个线程时，表示该线程可以进行操作，不会有多个线程竞争的情况
                  else {
                      Thread thisThread = Thread.currentThread(); //获取当前线程
                      leader = thisThread; //设置为正在操作的线程
                      try {
                          available.awaitNanos(delay); //等待消息的过期时间，保证下次循环的时候，对头那个消息一定时超时过期的
                      } finally {
                          if (leader == thisThread)
                              leader = null;
                      }
                  }
              }
          }
      } finally {
          if (leader == null && q.peek() != null)
              available.signal(); //唤醒下一个在等待的线程
          lock.unlock(); //解锁
      }
  }
一只小P熊
关注
专栏目录
(十五)java多线程之并发集合ArrayBlockingQueue
天之妖星的专栏
11-03 1万+
本人邮箱: kco1989@qq.com 欢迎转载,转载请注明网址 http://blog.csdn.net/tianshi_kco github: https://github.com/kco1989/kco 代码已经全部托管github有需要的同学自行下载 引言做java的同学们或多或少的接触过Java集合框架.在java集合框架中,大多的集合类是线程不安全的.比如我们常用的A
多线程学习笔记十一——java里的阻塞队列
星坠竹空
09-12 170
ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。 ·LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。 ·PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。 ·DelayQueue：一个使用优先级队列实现的无界阻塞队列。 可用于缓存，但redis已经有类似功能，所以感觉没什么用。 ·SynchronousQueu...
彻底弄懂ArrayBlockingQueue —— 超详细的原码分析
every__day的博客
12-19 2371
ArrayBlockingQueue 是常见的有界阻塞队列，用过线程池的，对它肯定不陌生。 它的实现原理，相信多数人也能说出个大概。可具体实现细节，估计会难住多数人。 我在网上查了一圈，大多是讲ArrayBlockingQueue怎么用的。它是怎么阻塞的，却少有人提及。 这里，由浅入深，我来剖析下ArrayBlockingQueue的源码，说说它到底是怎么阻塞的。 很可能，这是你能看到的，最详细的源码解析，不信的话，耐心看完，再和网上的比较下。 当然本人水平有限，若有论述不当之处，请大神指正。 ArrayB
一篇文章彻底搞懂BlockingQueue之ArrayBlockingQueue阻塞队列（深度剖析）
大尾巴狼学编程的博客
08-30 867
围绕队列、阻塞队列、ArrayBlockingQueue队列源码解析、入队、出队详解
阻塞队列 BlockingQueue【享学课堂】
牧码人
11-29 218
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIF...
深入理解(10)java并发之阻塞队列LinkedBlockingQueue与ArrayBlockingQueue
cowbin2012的专栏
05-01 1万+
原文：https://blog.csdn.net/javazejian/article/details/72772461 阻塞队列概要 阻塞队列与我们平常接触的普通队列(LinkedList或ArrayList等)的最大不同点，在于阻塞队列支出阻塞添加和阻塞删除方法。 阻塞添加 所谓的阻塞添加是指当阻塞队列元素已满时，队列会阻塞加入元素的线程，直队列元素不满时才重新唤醒线程执行元素加入操作。...
Java中常用的锁总结与理解
热门推荐
张彦峰的博客
05-12 166万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
深入剖析java并发之阻塞队列LinkedBlockingQueue与ArrayBlockingQueue
zejian的博客
08-31 9万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/77410889 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
深入理解Java虚拟机（读书笔记）
最新发布
汪子涵的博客
06-06 1125
JRE是支持Java程序运行的标准环境，包括：Java类库API中的Java SE API子集和Java虚拟机。JDK是支持Java程序开发的最小环境，包括：Java程序设计语言、Java虚拟机、Java类库。Java程序设计语言、Java虚拟机、Class文件格式、Java类库API、Java三方框架。动态语言支持：Java是静态语言，为其他运行在Java虚拟机上的动态语言提供支持。Lambda项目：支持Lambda表达式，支持函数式编程。Garbage-First收集器。
AQS源码深入分析之条件队列-阻塞队列是如何实现的吗？
m0_67698950的博客
07-04 297
因为CLH队列中的线程，什么线程获取到锁，什么线程进入队列排队，什么线程释放锁，这些都是不受我们控制的。所以条件队列的出现为我们提供了主动式地、只有满足指定的条件后才能线程阻塞和唤醒的方式。对于条件队列首先需要说明一些概念：条件队列是AQS中除了CLH队列之外的另一种队列，每创建一个Condition实际上就是创建了一个条件队列，而每调用一次await方法实际上就是往条件队列中入队，每调用一次signal方法实际上就是往条件队列中出队。不像CLH队列上节点的状态有多个，条件队列上节点的状态只有一个：COND
【并发】深入理解Java线程的底层原理
金鳞踏雨
11-29 985
操作系统会以进程为单位，分配系统资源（CPU时间片、内存等资源），进程是资源分配的最小单位。线程，有时被称为轻量级进程，是操作系统调度（CPU调度）执行的最小单位。Java 语言中线程共有六种状态，分别是： NEW（初始化状态） RUNNABLE（可运行状态+运行状态） BLOCKED（阻塞状态） WAITING（无时限等待） TIMED_WAITING（有时限等待） TERMINATED（终止状态）
java aio 底层用epoll_深入理解Java AIO（三）
weixin_31542739的博客
02-28 757
深入理解Java AIO(三)—— Linux中的AIO实现我们调用的Java AIO底层也是要调用OS的AIO实现，而OS主要也就Windows和Linux这两大类，当然还有Solaris和mac这些小众的。在 Windows 操作系统中，提供了一个叫做 I/O Completion Ports 的方案，通常简称为 IOCP，操作系统负责管理线程池，其性能非常优异，所以在 Windows 中 J...
【深入理解Java原理】并发编程
王小明的专栏
07-25 301
并发编程 乐观锁理论： 冲突检测和数据更新， CAS 理论： compare and set 相对于synchronized 这种阻塞方式，CAS采用的是非阻塞算法，可以很大提升性能 包含三个操作数 ：内存值V 预期值A，新值B 查看内存位置V是否与预期值A一致，如果是更新为B， 如果不匹配，不做任何操作 CAS理论存在ABA 问题： ABA问题： ...
【Java多线程】JUC之并发容器—深入剖析并发队列ConcurrentLinkedQueue(九)
墩墩分墩
03-09 2124
**ConcurrentLinkedQueue**:是一个适用于**高并发场景**，基于`单向链表`实现的`无界非阻塞线程安全队列`，使用`CAS自旋+volatile`来包保证线程安全。按照`FIFO`的方式对存储元素进行排序，该队列`不允许写入null元素`。 - 由于是完全基于`无锁算法`实现的，多线程同时进行修改队列的操作（比如同时入队），很可能出现`CAS修改失败`的情况，那么失败的线程`会进入下一次自旋，再尝试入队操作，直到成功`。**所以，在并发量适中的情况下，ConcurrentLinked
【P说】并发与并行
solo_jm的博客
05-09 1865
并行 并行是指同一时间可以执行的线程数量，注意这里强调的是同时，假如有一块八核的CPU，那么它的并行数为8，因为它同时可以跑八个线程。 并发 与并行不同，并发强调的是单位时间内，也就是一段时间内跑了多少个线程，同样假设有一块八核的CPU，同时一个线程需要20ms跑完，那么100ms内的并发数就为：8（CPU核心数）*5（一个核心100ms可以跑的线程）= 40。 区分关键 并行强调的是同时，而并发强调的是一段时间内。 例子 以打饭为例子，现在有两个打饭的窗口。同时，只有两个人可以打饭，那么2就是并行数。假如
【P说】深入理解AQS
solo_jm的博客
05-19 1357
简介 AQS全称为AbstractQueuedSynchronizer，是一个抽象类，主要是通过继承的方式来使用，其内部维护了一个同步队列，AQS是一个用来实现同步锁以及其他涉及到同步功能的核心组件。 使用的设计模式 AQS使用了模板方法设计模式，这里只做大致的介绍，所谓模板模式，就是有一个抽象类公开定义了执行它的方法的方式/模板。继承它的子类需要重写方法的具体细节，但是调用将以抽象类中定义的方式进行。比如，一个烧水的过程，在模板模式中，抽象类会定义一整个过程，包括拿壶，倒水，开火等，而继承它的子类负责实现
【P说】浅谈Fork/Join
solo_jm的博客
05-13 341
简述 ForkJoin是由JDK1.7后提供多线并发处理框架。它的基本思想是分而治之。 分而治之 规模为N的问题，N<阈值，直接解决，N>阈值，将N分解为K个小规模子问题，子问题互相对立，与原问题形式相同，将子问题的解合并得到原问题的解。 ForkJoin的工作秘取（work-stealing） 由于ForkJoin的执行时多线程的，因此总会出现，有的线程已经执行完了，其他线程还没执行或者还在执行的情况，这个时候执行完的线程假如只是等待另一个线程执行完，效率就太低了。因此，在线程A执行完毕后，
【P说】多线程HashMap产生死循环
solo_jm的博客
05-20 315
简介 在1.7及以前，使用HashMap进行put操作时，当元素超过阈值时，会触发resize操作，这时候可能就会出现死循环的情况，导致CPU占用率达到100%。 原因 归根结底，就是JDK 1.7链表新节点采用的是头插法，这样在线程一扩容迁移元素时，会将元素顺序改变，导致两个线程中出现元素的相互指向而形成循环链表，JDK 1.8之后采用了尾插法，从根源上杜绝了这种情况的发生。 数据结构 首先，我们要先了解HashMap的数据结构，HashMap的主干是一个Entry数组。Entry是HashMap的基本组
Java并发编程：深入理解阻塞队列及其关键实现
Java并发编程中的阻塞队列是一种特殊的数据结构，它在普通队列的基础上引入了阻塞机制，使得在多线程环境下能够更好地管理资源并发访问。阻塞队列的核心理念是，当队列为空（消费者尝试取元素）或已满（生产者试图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值