java多线程：线程池常用的三种队列详解！

最新推荐文章于 2024-09-14 08:40:46 发布
最新推荐文章于 2024-09-14 08:40:46 发布
阅读量1w 收藏 19
点赞数 2
分类专栏： 线程池 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoliubao1/article/details/103024002
版权

开篇：我们在初始化线程池的时候常常会使用到如下三种队列，他们分别是：

LinkedBlockingDeque（链表同步阻塞队列）、ArrayBlockingQueue（数组同步阻塞队列）、SynchronousQueue（同步阻塞队列）

他们与线程池的的maximumPoolSize参数结合使用时会有不同的效果。

通过实验来说明：

1.使用ArrayBlockingQueue

（1）.源码

 public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

（2）.代码实例

        a.当Runnable的数量小于等于maximumPoolSize与阻塞队列的和

package com.springboot.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadQueueTest {
    public static void main(String[] args) {
        ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked);
        ThreadQueueRunnable runnable  = new ThreadQueueRunnable();
        System.out.println("before thread pool execute linked size is :"+linked.size());
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        System.out.println("after thread pool execute linked size is :"+linked.size());
        System.out.println("thread pool size is:" + threadPoolExecutor.getPoolSize());
    }
}


class ThreadQueueRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("--------------------");
        System.out.println(Thread.currentThread().getName());
        System.out.println("---------------------");
    }
}

运行结果：

before thread pool execute linked size is :0
--------------------
pool-1-thread-1
---------------------
--------------------
pool-1-thread-3
---------------------
--------------------
pool-1-thread-3
---------------------
after thread pool execute linked size is :2
thread pool size is:3
--------------------
pool-1-thread-2
---------------------
--------------------
pool-1-thread-1
---------------------

b.当Runnable的数量大于maximumPoolSize与阻塞队列的和

package com.springboot.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadQueueTest {
    public static void main(String[] args) {
        ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked);
        ThreadQueueRunnable runnable  = new ThreadQueueRunnable();
        System.out.println("before thread pool execute linked size is :"+linked.size());
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        System.out.println("after thread pool execute linked size is :"+linked.size());
        System.out.println("thread pool size is:" + threadPoolExecutor.getPoolSize());
    }
}


class ThreadQueueRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("--------------------");
        System.out.println(Thread.currentThread().getName());
        System.out.println("---------------------");
    }
}

运行结果：

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.springboot.thread.ThreadQueueRunnable@58372a00 rejected from java.util.concurrent.ThreadPoolExecutor@4dd8dc3[Running, pool size = 3, active threads = 3, queued tasks = 2, completed tasks = 0]
before thread pool execute linked size is :0
--------------------
pool-1-thread-1
---------------------
--------------------
pool-1-thread-1
---------------------
--------------------
pool-1-thread-1
---------------------
--------------------
pool-1-thread-2
---------------------
--------------------
pool-1-thread-3
---------------------
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
	at com.springboot.thread.ThreadQueueTest.main(ThreadQueueTest.java:18)

总结一下：当我们使用ArrayBlockingQueue时，当runnable的数量小于等于线程池的大小与队列的和时，会先将部分runnable存到线程池中立刻开始执行，将剩余的runnable存入阻塞队列中。当runnable的数量大于线程池的数量与阻塞队列之和时会将线程池+阻塞队列数量的runnable执行，并抛出RejectedExecutionException，使用LinkedBlockingDeque时同理。

（LinkedBlockingQueue和LinkedBlockingDeque分析：参考  https://blog.csdn.net/anLA_/article/details/79027867）

2.使用SynchronousQueue 

  a.当Runnable的数量小于等于maximumPoolSize

package com.springboot.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadQueueTest {
    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        SynchronousQueue linked = new SynchronousQueue();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked);
        ThreadQueueRunnable runnable  = new ThreadQueueRunnable();
        System.out.println("before thread pool execute linked size is :"+linked.size());
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        //threadPoolExecutor.execute(runnable);
        System.out.println("after thread pool execute linked size is :"+linked.size());
        System.out.println("thread pool size is:" + threadPoolExecutor.getPoolSize());
    }
}


class ThreadQueueRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("--------------------");
        System.out.println(Thread.currentThread().getName());
        System.out.println("---------------------");
    }
}

运行结果：

before thread pool execute linked size is :0
after thread pool execute linked size is :0
thread pool size is:3
--------------------
pool-1-thread-1
---------------------
--------------------
pool-1-thread-3
---------------------
--------------------
pool-1-thread-2
---------------------

b.当Runnable的数量大于maximumPoolSize

package com.springboot.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadQueueTest {
    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        SynchronousQueue linked = new SynchronousQueue();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked);
        ThreadQueueRunnable runnable  = new ThreadQueueRunnable();
        System.out.println("before thread pool execute linked size is :"+linked.size());
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        System.out.println("after thread pool execute linked size is :"+linked.size());
        System.out.println("thread pool size is:" + threadPoolExecutor.getPoolSize());
    }
}


class ThreadQueueRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("--------------------");
        System.out.println(Thread.currentThread().getName());
        System.out.println("---------------------");
    }
}

运行结果：

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.springboot.thread.ThreadQueueRunnable@4dd8dc3 rejected from java.util.concurrent.ThreadPoolExecutor@6d03e736[Running, pool size = 3, active threads = 3, queued tasks = 0, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
	at com.springboot.thread.ThreadQueueTest.main(ThreadQueueTest.java:18)
before thread pool execute linked size is :0
--------------------
pool-1-thread-1
---------------------
--------------------
pool-1-thread-3
---------------------
--------------------
pool-1-thread-2
---------------------

总结一下:当我们使用同步阻塞队列时，同步阻塞队列没有大小，当runnable的数量小于等于线程池的大小时每执行一次 threadPoolExecutor.execute(runnable);线程池的大小会加1，当超过线程池的的大时不再执行多余的任务并抛出RejectedExecutionException异常。

补代码：

package com.springboot.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadQueueTest {
    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        SynchronousQueue linked = new SynchronousQueue();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked);
        ThreadQueueRunnable runnable  = new ThreadQueueRunnable();
        System.out.println("before thread pool execute linked size is :"+linked.size());
        System.out.println("thread pool size is:" + threadPoolExecutor.getPoolSize());
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        //threadPoolExecutor.execute(runnable);
        System.out.println("thread pool size is:" + threadPoolExecutor.getPoolSize());
        threadPoolExecutor.execute(runnable);
        System.out.println("after thread pool execute linked size is :"+linked.size());
        System.out.println("thread pool size is:" + threadPoolExecutor.getPoolSize());
    }
}


class ThreadQueueRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("--------------------");
        System.out.println(Thread.currentThread().getName());
        System.out.println("---------------------");
    }
}

运行结果：

before thread pool execute linked size is :0
thread pool size is:0
thread pool size is:2
after thread pool execute linked size is :0
--------------------
pool-1-thread-2
---------------------
thread pool size is:3
--------------------
pool-1-thread-3
---------------------
--------------------
pool-1-thread-1
---------------------

 

Java多线程：线程池详解（1）
流楚丶格念的博客
07-16 1752
线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就。​系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系。等待下一次任务的执行。通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。概述JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。...
Java四种线程池和工作队列
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
12-02 4521
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUn
多线程：线程池里的队列BlockingQueue
五山口老法师
01-13 1206
runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。 可以选择以下几个阻塞队列： BlockingQueue的几个注意点 【1】BlockingQueue 可以是限定容量的。它在任意给定时间都可以有一个remainingCapacity，超出此容量，便无法无阻塞地put 附加元素。没有任何内部容量约束的BlockingQueue 总是报告Integer.MAX_V...
19.线程池中的队列
郑学炜的技术博客
05-18 9275
runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。 可以选择以下几个阻塞队列：BlockingQueue的几个注意点【1】BlockingQueue 可以是限定容量的。它在任意给定时间都可以有一个remainingCapacity，超出此容量，便无法无阻塞地put 附加元素。没有任何内部容量约束的BlockingQueue 总是报告Integer.MAX_VALUE...
java重点学习-线程池
最新发布
qq_40453972的博客
09-14 1088
你们项目哪里用到了多线程
【多线程】线程池中的队列有哪些，应该如何选择
qq_39666711的博客
07-17 1730
线程池中的队列是线程池的重要组成部分，用于存放待执行的任务。在Java中，线程池常用的队列类型包括无界队列、有界队列、直接提交队列（SynchronousQueue）、优先级队列等。
Java线程池中队列常用类型有哪些？
NZC2237的博客
01-12 1839
每种队列类型都有自己适用的场景和特点，选择合适的队列类型可以根据具体的线程池任务和需求。常用的是 `LinkedBlockingQueue` 和 `ArrayBlockingQueue`，分别用于无界队列和有界队列，适应性较广。基于链表实现的阻塞队列，容量可选，若不指定容量，默认为 `Integer.MAX_VALUE`。一个不存储元素的阻塞队列，每个插入操作必须等待一个相应的删除操作，反之亦然。适用于任务数比较多的情况，任务数量不受限制，可以有效地缓冲任务。适用于固定大小的线程池，可以控制最大任务数量。
线程池都有哪几种工作队列
热门推荐
weixin_34033624的博客
04-09 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
Java线程池使用说明
xkhzk2的博客
07-30 333
Java线程池使用说明 一 简介 线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。 二：线程池 线程池的作用： 线程池作用就...
多线程与线程池技术详解（图书配套）
07-01
多线程与线程池是Java编程中至关重要的概念，特别是在处理高并发场景时，它们的作用尤为突出。本文将深入探讨这两个主题，并结合标签中的"排它锁"、"重入锁"、"共享锁"等概念进行讲解。 首先，线程是操作系统分配...
多线程与线程池技术详解
06-12
在Java编程领域，多线程和线程池技术是核心且关键的概念，它们在现代的高性能、高并发应用中扮演着重要角色。多线程允许应用程序同时执行多个任务，而线程池则是一种管理和控制线程的有效手段，有助于提高系统的效率...
java 线程池和 队列
wwp231的博客
09-11 427
一，队列 实例：package senior.queue;import java.util.LinkedList; import java.util.Queue;/** * Created by Administrator on 2016/9/11. */ public class QueueTest { public static void main(String[] args
Java线程池可用的队列
weixin_33857230的博客
01-25 185
Java线程池ThreadPoolExecutor的构造器： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, ...
Java 线程池 队列
long704480904
10-29 902
1.使用线程池的目的:
线程池任务队列的常用类型
qq_39350797的博客
06-04 771
线程池任务队列的常用类型
线程池队列
watson1360884839的博客
09-18 991
ArrayBlockingQueue：基于数组的FIFO队列，是有界的，创建时必须指定大小 LinkedBlockingQueue： 基于链表的FIFO队列，是无界的，默认大小是 Integer.MAX_VALUE synchronousQueue:一个比较特殊的队列，虽然它是无界的，但它不会保存任务，每一个新增任务的线程必须等待另一个线程取出任务，也可以把它看成容量为0的队列    排队有三...
Java多线程深入：线程池原理与Executor框架详解
本章节深入探讨了Java多线程编程的基础和Java.util.concurrent包中的Java Universal Classes (JUC) 对多线程的支持。主要内容包括以下几个关键知识点： 1. **线程池**：线程池是管理线程资源的关键概念，它通过预先...
java线程池和队列
致终将逝去的编程青春
10-20 529
java线程池和队列
线程池任务队列
fengsh998的专栏
09-22 6404
unit uPool; {*********************************************************************** 线程池+任务队列 整个线程池调度图 ==============================================
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值