使用ThreadPoolExecutor自定义线程池

最新推荐文章于 2026-03-23 20:48:17 发布
原创 最新推荐文章于 2026-03-23 20:48:17 发布 · 2.1k 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
多线程

当前文章被收录于：

多线程
12 篇文章 2 人学习

多线程

订阅专栏 查看详情
本文深入探讨Java线程池的工作原理及其实现细节，包括线程池的主要组件、构造函数参数的意义、线程池的使用规则及状态变化等内容。

线程池（Thread Pool）是一种基于池化思想管理线程的工具。可以想象成把一些线程放到一个“池子”中，统一管理。
Java封装了一些线程池给开发者使用

1、Executors.newSingleThreadExecutor()  创建只有一个线程的线程池
2、Executors.newFixedThreadPool(int nThreads)  创建具有指定数量线程数的线程池
3、Executors.newCachedThreadPool()   创建一个线程池，线程池中的线程空闲时间超过60秒就销毁线程
4、Executors.newScheduledThreadPool(2)  创建有定时功能的线程池

使用Executors.newFixedThreadPool(int nThreads) 简单演示线程池的使用。

    public static void main(String[] args) throws Exception{
        // 创建线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 5; i++) {
            es.execute(() -> {
                System.out.println(Thread.currentThread().getName()+" 线程运行");
            });
        }
        // 关闭线程池
        es.shutdown();
    }

Executors.newSingleThreadExecutor() 、Executors.newFixedThreadPool(int nThreads) 、Executors.newCachedThreadPool()、Executors.newScheduledThreadPool(int nThreads)都是使用ThreadPoolExecutor创建线程池。本文重点讲解ThreadPoolExecutor。ThreadPoolExecutor有4个构造函数，我们用参数最多的构造函数讲解。

ThreadPoolExecutor构造函数

ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler)

corePoolSize

保留在池中的线程数，即使线程处于空闲状态，也会在池中保留corePoolSize个线程。

maximumPoolSize

池中允许的最大线程数。

对于CPU密集型应用，最大线程数应等于CPU核心数。

对于I/O密集型应用，绝大部分的web后端服务属于I/O密集型应用，最大线程数有两个计算公式。

1、最大线程数 = CPU期望利用率 * CPU核心数 * (1 + 线程平均等待时间 / 线程平均工作时间)

2、最大线程数 = CPU期望利用率 * CPU核心数 / (1-阻塞系数)。由于 阻塞系数 = 阻塞时间 /（阻塞时间+计算时间），1和2其实是同一个公式，只是写法不同。

使用Runtime.getRuntime().availableProcessors(); 可得到ava虚拟机可用的CPU核心数量。至于线程平均等待时间、线程平均工作时间，每个应用不同，无法给出具体值。

/**
 * I/O密集型应用，最大线程数量
 */
private static int ioMaximumPoolSize() {
	// CPU期望利用率设置为100%，尽量利用CPU
	int cpuUsePercent = 1;

	// Java虚拟机可用的CPU核心数量
	int jvmAvailableProcessors = Runtime.getRuntime().availableProcessors();

	// 假设线程平均等待时间和线程平均工作时间的比值是8
	int blockTime = 8;
	int runTime = 1;

	int ioMaxCore = cpuUsePercent * jvmAvailableProcessors * (1 + blockTime/runTime);
	return ioMaxCore;
}

keepAliveTime

池中线程数超过了corePoolSize，这些超出的线程在keepAliveTime时间内不被使用，则这些线程会被销毁。

unit

keepAliveTime的时间单位。

workQueue

阻塞队列BlockingQueue<Runnable>，由于是队列，所以具备先进先出的特性（FIFO）。当队列满了，往队列加元素会阻塞；队列为空，从队列取元素会造成阻塞。此接口的常用的实现类有两个LinkedBlockingQueue和ArrayBlockingQueue。

ArrayBlockingQueue和LinkedBlockingQueue主要有以下区别：

1、ArrayBlockingQueue基于数组实现，是有界队列，即创建ArrayBlockingQueue必须指定队列容量。LinkedBlockingQueue基于链表实现，创建LinkedBlockingQueue时可以指定队列容量也可以不指定队列容量，不指定队列容量时，队列容量是Integer.MAX_VALUE。
2、ArrayBlockingQueue使用一个锁控制入队出队。LinkedBlockingQueue使用两个锁控制入队出队，一个putLock，一个takeLock。
3、根据官方描述链表队列通常比基于数组的队列具有更高的吞吐量，但在大多数并发应用程序中，性能的可预测性较差。

threadFactory

创建线程的工厂。不指定线程工厂时，默认使用Executors.defaultThreadFactory()创建线程工厂。

handler

当任务超过maximumPoolSize + workQueue之和，任务提交给handler处理，Java提供了4种handler。

ThreadPoolExecutor.AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。默认策略。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）。
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

下面是一个线程池工具类

/**
 * 线程池工具
 */
public final class ThreadUtil {
	private static final Logger LOGGER = LoggerFactory.getLogger(ThreadUtil.class);
	private static ThreadPoolExecutor executor = null;
	private ThreadUtil() {}

	static{
		initExecutor();
	}

	/**
	 * 初始化
	 */
	private static void initExecutor(){
		// 核心线程数
		int  corePoolSize = Runtime.getRuntime().availableProcessors();
		corePoolSize = corePoolSize < 2 ? 2 : corePoolSize;

		// 最大线程数
		int maximumPoolSize = ioMaximumPoolSize();
		maximumPoolSize = maximumPoolSize < corePoolSize ? corePoolSize : maximumPoolSize;

		LOGGER.info("初始化线程池 corePoolSize:{} , maximumPoolSize:{}" , corePoolSize , maximumPoolSize);

		ThreadFactory defaultThreadFactory = Executors.defaultThreadFactory();

		executor = new ThreadPoolExecutor(corePoolSize , maximumPoolSize ,
				60L, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(10000),
				defaultThreadFactory,
				new CustomAbortPolicy());
	}


	/**
	 * I/O密集型应用，最大线程数量
	 */
	private static int ioMaximumPoolSize() {
		// CPU期望利用率设置为100%，尽量利用CPU
		int cpuUsePercent = 1;

		// Java虚拟机可用的CPU核心数量
		int jvmAvailableProcessors = Runtime.getRuntime().availableProcessors();

		// 假设线程平均等待时间和线程平均工作时间的比值是8
		int blockTime = 8;
		int runTime = 1;

		int ioMaxCore = cpuUsePercent * jvmAvailableProcessors * (1 + blockTime/runTime);
		return ioMaxCore;
	}

	/**
	 * 自定义线程池饱和策略，模仿AbortPolicy（终止线程策略）
	 *
	 * A handler for rejected tasks that throws a
	 * {@code RejectedExecutionException}.
	 */
	public static class CustomAbortPolicy implements RejectedExecutionHandler {
		/**
		 * Creates an {@code AbortPolicy}.
		 */
		public CustomAbortPolicy() { }

		/**
		 * Always throws RejectedExecutionException.
		 *
		 * @param r the runnable task requested to be executed
		 * @param e the executor attempting to execute this task
		 * @throws RejectedExecutionException always
		 */
		@Override
		public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

			// 模仿ThreadPoolExecutor.AbortPolicy的写法，仅是修改了这行代码，并加了个注释
			String msg = String.format("线程池任务满了，抛出异常。\nTask: %s 。\nRejected from: %s",r.toString(), e.toString());
			LOGGER.error(msg);
			// 发送邮件或者发送钉钉消息

			throw new RejectedExecutionException("Task " + r.toString() +
					" rejected from " +
					e.toString());
		}
	}

	/**
	 * 在公共线程池中执行任务
	 *
	 * @param runnable 可运行对象
	 */
	public static void execute(Runnable runnable) {
		executor.execute(runnable);
	}
}

线程池添加线程的规则

为了更好的讲解线程池新建线程的规则，暂时把corePoolSize、maximumPoolSize、keepAliveTime、LinkedBlockingQueue的容量改小。

executor = new ThreadPoolExecutor(2 , 4 ,
                10L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                defaultThreadFactory,
                new CustomAbortPolicy());

1、线程池创建成功，但没运行任务，线程池中线程数为0。

在ThreadUtil类中添加main函数测试

	public static void main(String[] args) throws Exception{
		System.out.println("线程池创建成功，但没运行任务："+executor);
	}

打印结果：

线程池创建成功，但没运行任务：java.util.concurrent.ThreadPoolExecutor@3fa77460[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]

2、线程池运行任务，新建线程，活跃线程数大于核心线程数时，将任务添加到队列中。

	public static void main(String[] args) throws Exception{
        for (int i = 0; i < 4; i++) {
            // 睡眠，让任务一个接一个地提交
            TimeUnit.MILLISECONDS.sleep(10);
            execute(() -> {
                try {
                    // 睡眠，避免任务过早结束
                    TimeUnit.MILLISECONDS.sleep(200);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            });
            System.out.println("线程池信息："+executor);
        }

        TimeUnit.SECONDS.sleep(12);
        System.out.println("任务运行完毕后："+executor);
	}

打印结果：

线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 1, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 2, completed tasks = 0]
任务运行完毕后：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 0, queued tasks = 0, completed tasks = 4]

3、线程池正在运行的任务大于核心线程数与队列容量之和，继续创建线程，直到线程数达到最大线程数。达到最大线程数后，线程空闲时间超过keepAliveTime，超出的线程终止，最后保留corePoolSize个活跃线程。

	public static void main(String[] args) throws Exception{
        for (int i = 0; i < 7; i++) {
            // 睡眠，让任务一个接一个地提交
            TimeUnit.MILLISECONDS.sleep(10);
            execute(() -> {
                try {
                    // 睡眠，避免任务过早结束
                    TimeUnit.MILLISECONDS.sleep(200);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            });
            System.out.println("线程池信息："+executor);
        }

        TimeUnit.SECONDS.sleep(5);
        System.out.println("任务运行完毕后："+executor);

        TimeUnit.SECONDS.sleep(12);
        System.out.println("超过线程空闲时间没提交新任务："+executor);
	}

打印结果：

线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 1, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 2, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 3, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 3, active threads = 3, queued tasks = 3, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 4, active threads = 4, queued tasks = 3, completed tasks = 0]
任务运行完毕后：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 4, active threads = 0, queued tasks = 0, completed tasks = 7]
超过线程空闲时间没提交新任务：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 0, queued tasks = 0, completed tasks = 7]

4、线程池正在运行的任务数大于最大线程数+队列容量之和，超出的任务由线程池饱和策略处理。线程池的线程抛出异常后，仅仅是线程被终止了，但线程池中的其他线程还能继续使用。

	public static void main(String[] args) throws Exception{
        for (int i = 0; i < 8; i++) {
            // 睡眠，让任务一个接一个地提交
            TimeUnit.MILLISECONDS.sleep(10);
            try {
                execute(() -> {
                    try {
                        // 睡眠，避免任务过早结束
                        TimeUnit.MILLISECONDS.sleep(200);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                });
            }catch (Exception e){
                // 捕获线程池抛出的异常，以便本线程能继续执行后面的代码
                e.printStackTrace();
            }
            System.out.println("线程池信息："+executor);
        }

        TimeUnit.SECONDS.sleep(5);
        System.out.println("任务运行完毕后："+executor);

        TimeUnit.SECONDS.sleep(12);
        System.out.println("超过线程空闲时间没提交新任务："+executor);

        // 再次使用线程运行任务
        executor.execute(() -> {
            System.out.println("线程池的线程抛出异常后，仅仅是线程被终止了，但线程池中的其他线程还能继续使用");
        });
	}

打印结果：

线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 1, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 2, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 2, queued tasks = 3, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 3, active threads = 3, queued tasks = 3, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 4, active threads = 4, queued tasks = 3, completed tasks = 0]
11:26:55.130 [main] ERROR com.example.bingfa02.ThreadUtil - 线程池任务满了，抛出异常。
Task: com.example.bingfa02.ThreadUtil$$Lambda$1/231685785@6504e3b2 。
Rejected from: java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 4, active threads = 4, queued tasks = 3, completed tasks = 0]
线程池信息：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 4, active threads = 4, queued tasks = 3, completed tasks = 0]
java.util.concurrent.RejectedExecutionException: Task com.example.bingfa02.ThreadUtil$$Lambda$1/231685785@6504e3b2 rejected from java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 4, active threads = 4, queued tasks = 3, completed tasks = 0]
    at com.example.bingfa02.ThreadUtil$CustomAbortPolicy.rejectedExecution(ThreadUtil.java:91)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
    at com.example.bingfa02.ThreadUtil.execute(ThreadUtil.java:101)
    at com.example.bingfa02.ThreadUtil.main(ThreadUtil.java:109)
任务运行完毕后：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 4, active threads = 0, queued tasks = 0, completed tasks = 7]
超过线程空闲时间没提交新任务：java.util.concurrent.ThreadPoolExecutor@75a1cd57[Running, pool size = 2, active threads = 0, queued tasks = 0, completed tasks = 7]
线程池的线程抛出异常后，仅仅是线程被终止了，但线程池中的其他线程还能继续使用

线程池的状态

1、执行shutdown()方法后，不再接收新任务，队列中的任务会被执行完毕。

	public static void main(String[] args) throws Exception{
        for (int i = 0; i < 7; i++) {
            // 睡眠，让任务一个接一个地提交
            TimeUnit.MILLISECONDS.sleep(10);
            execute(() -> {
                try {
                    // 睡眠，避免任务过早结束
                    TimeUnit.MILLISECONDS.sleep(200);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            });
            //System.out.println("线程池信息："+executor);
        }

        TimeUnit.MILLISECONDS.sleep(80);
        System.out.println("关闭线程池之前："+executor);

        executor.shutdown();
        System.out.println("执行shutdown()，等待队列任务执行完毕："+executor);

        try {
            executor.execute(() -> System.out.println("关闭线程池后提交任务，会抛出异常"));
        }catch (Exception e){
            e.printStackTrace();
        }

        TimeUnit.MILLISECONDS.sleep(2000);
        System.out.println("所有任务运行完毕："+executor);
	}

2、执行shutdownNow()方法，不再接受新任务，丢弃队列的任务，中断正在执行的任务。

	public static void main(String[] args) throws Exception{
	    Integer a = null;
        for (int i = 0; i < 7; i++) {
            execute(() -> {
                Integer b = a;
                /**
                 * 任务的run()方法没有响应中断的代码，执行shutdownNow()也无法立刻停止线程，要等run()方法运行结束。
                 * 每个计算机的性能不同，可动态修改j的大小。
                 *
                 * 线程的状态和中断可以查看这两篇博客
                 * https://blog.csdn.net/u010606397/article/details/103891954
                 * https://blog.csdn.net/u010606397/article/details/109090806
                 */
                for (int j = 0; j < 10000000; j++) {
                    b = new Random().nextInt();
                }
                System.out.println("当前线程中断状态："+Thread.currentThread().isInterrupted());
            });

        }

        System.out.println("关闭线程池之前："+executor);

        executor.shutdownNow();
        System.out.println("执行shutdownNow()："+executor);

        try {
            executor.execute(() -> System.out.println("关闭线程池后提交任务，会抛出异常"));
        }catch (Exception e){
            e.printStackTrace();
        }
	}

使用无界队列导致OutOfMemoryError

线程池的阻塞队列使用了无界队列时，有内存溢出风险。下面模拟内存溢出的场景。

1、阻塞队列使用无界队列new LinkedBlockingQueue<Runnable>()

        executor = new ThreadPoolExecutor(2 , 4 ,
                10L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(),
                defaultThreadFactory,
                new CustomAbortPolicy());

2、将jvm内存设置得小一点 -Xms20m -Xmx20m

3、循环执行execute方法，将任务加到无界队列中

	public static void main(String[] args) throws Exception{
	    Integer a = null;
	    // 循环执行execute方法，将大量任务加入无界队列中，造成内存溢出
        for (int i = 0; i < 10000000; i++) {
            execute(() -> {
                Integer b = a;
				try {
					// 睡眠保持线程不退出
					TimeUnit.SECONDS.sleep(60);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				b = new Random().nextInt();
            });
        }
        
	}

4、运行一段时候后抛出OutOfMemoryError异常

需要注意的是，Executors.newSingleThreadExecutor() 、Executors.newFixedThreadPool(int nThreads) 源码中也使用无界队列new LinkedBlockingQueue<Runnable>()实现，有OutOfMemoryError风险。Executors.newCachedThreadPool()、Executors.newScheduledThreadPool(int nThreads)的最大线程数是Integer.MAX_VALUE，有可能因短时间内创建大量线程而导致OutOfMemoryError。最好是自己定义一个线程池，不用Java提供的，毕竟业务场景有千千万万种，Java设计者也无法给出一个完美的解决方案。

 

 

 

AFSim编译一：windows
Meepo的博客
09-16 4644
AFSim在windows上的编译
基于改进Unet的多场景水果图像分割与分类研究
最新发布
AI的内部世界的博客
03-23 276
本文针对复杂场景下的水果图像分割问题，提出了一种改进Unet模型。通过构建包含8类水果、3种成熟度及多种干扰场景的数据集，采用ResNet50与MobileNetV3作为骨干网络，并在跳跃连接层集成CBAM注意力机制。实验表明，改进模型在测试集上达到91.6%的mIoU，推理速度提升23%，特别在重叠水果和低光照场景表现突出。研究为农业视觉检测提供了有效解决方案。
自定义线程池内置线程池的使用 ThreadPoolExecutor和Executorservice 示例与注意事项
qq_41358574的博客
12-10 1968
文章目录线程池介绍自己设计一个线程池1.设计ThreadPool类：2.设计工作队列3.实现自己设计的线程池用java的ThreadPoolExecutor自定义线程池自定义线程池-参数设计分析自定义线程池-实现步骤内置线程池ExecutorServiceScheduledexecutorservice 线程池介绍 自JDK1.5起，utils包提供了ExecutorService线程池的实现，主要目的是为了重复利用线程，提高系统效率。我们知道Thread是一个重量级的资源，创建、启动以及销毁都是比较耗费系
TB6612电机驱动模块TB6612驱动板ALTIUM设计硬件原理图PCB+3D集成封装库.zip
TB6612电机驱动模块TB6612驱动板ALTIUM设计硬件原理图PCB+3D集成封装库，硬件2层板设计，大小为18mmx18mm，ALTIUM设计的工程文件，包括完整的原图、PCB、3D封装库文件，已制板测试验证，可以做为你的设计参考。集成库型号列表：
专项攻克——线程池
军威兄的博客
09-03 7030
文章目录五种线程池的使用场景线程池的继承关系线程池的具体实现类ThreadPoolExecutor的重要参数==线程池的几步主要工作流程思路分析==线程池都有哪几种工作队列 多线程面试问题 参考博客 五种线程池的使用场景 一个使用线程池管理线程的例子：//创建一个可重用固定线程数量的线程池 ExecutorService pool = Executors.newFixedThreadPool...
线程池Executors.newFixedThreadPool
热门推荐
bobo8945510的博客
08-06 4万+
线程池Executors.newFixedThreadPool
多线程理解（二）
逝去的往事的博客
11-10 6351
线程安全的问题 关于线程安全问题，有一个经典的问题----银行取钱的问题。银行取钱的基本流程如下： 用户输入账户、密码，系统判断用户的账户、密码是否匹配； 用户输入取款金额； 系统判断账户余额是否大于取款金额； 如果余额大于取款金额，则取款成功；如果余额小于取款金额，则取款失败； 如果将这个流程放在多线程并发的场景下，就有可能出现问题； 同步代码块 为了解决这个问题，Java的多线程支持引入了...
java线程池(二) Executors.newFixedThreadPool
喜欢炒股的码农
09-27 8990
使用这种方法实现一个线程池Executors.newFixedThreadPool，我们就必须要提到ThreadPoolExecutor这个类。这种线程池的实现就是实例化了一个ThreadPoolExecutor对象并进行后续的处理。 实例化ThreadPoolExecutor 传入指定线程池的容量大小。 public static ExecutorService newFixedTh
Java — 慎用Executors类中newFixedThreadPool()和newCachedThreadPool()
zhangdm的博客
12-01 1万+
慎用Executors类中newFixedThreadPool()和newCachedThreadPool()
自定义线程池之ThreadPoolExecutor的使用
hanxiexcellent的博客
04-02 659
了解原因 在阿里规约里面，有这样一条规则： 这里提到了使用ThreadPoolExecutor来创建线程池，其实这就是我们常常听说的“自定义线程池”。该类位于java的java.util.concurrent包下。至于使用自定义的好处，上面的图片已经可以说明，接下来我们从概念到实战，分析一下这个类。 概念 ThreadPoolExecutor类间接实现了ExecutorService接口。通常经使用Executors类的工厂方法设置后，它能够从一些可能池化管理的线程里面选择一个来执行每个已经提交的任务。
ThreadPoolExecutor自定义线程池的使用及同步化处理
CSDN已弃用
05-26 3056
参照官方api文档地址：https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ThreadPoolExecutor.html An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods. Th
ThreadPoolExecutor自定义创建线程池使用有界队列
qq_19779823的博客
04-25 1453
  在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，   若大于corePoolSize，则会将任务加入队列，   若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，   若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。import java.util.concurr...
java中四种线程池的创建与使用，ThreadPoolExecutor的分析
Gedulding的博客
04-04 3824
Executors工厂类的四种线程池的创建,newFixedThreadPool、newSingleThreadExecutor、newScheduledThreadPool和newCachedThreadPool。 以及对ThreadPoolExecutor的分析。
【Thread】线程池的 7 种创建方式及自定义线程池
sco5282的博客
11-06 3万+
1. 什么是线程池 线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制。它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。 使用线程池主要有以下优点： 降低资源消耗 提高响应速度 提高线程的可管理性 同时，阿里巴巴在其《Java开发手册》中也强制规定：线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 2. 使用线程池 线程池的创建方法总共有 7 种，但总体来说可分为 2 类：
Executors线程池详解（全）
qq_33642970的博客
04-10 2298
开场白 构造一个线程池为什么需要几个参数？如果避免线程池出现OOM？Runnable和Callable的区别是什么？本文将对这些问题一一解答，同时还将给出使用线程池的常见场景和代码片段。 基础知识 Executors创建线程池 Java中创建线程池很简单，只需要调用Executors中相应的便捷方法即可，比如Executors.newFixedThreadPool(int nThreads...
线程池使用和自定义线程池
mocas_wang的博客
08-10 2803
目录 1 线程基础概述 1.1，线程池的作用 1.2，为什么要用线程池? 1.3，比较重要的几个类 1.4，new Thread的弊端 2 四种线程池 2.1 源码分析 2.2 RejectedExecutionHandler 线程池四种拒绝任务策略 2.3 示例使用 1，newCachedThreadPool 2，newFixedThreadPool 3，newScheduledThreadPool 4，newSingleThreadExecutor 1 线程基础...
线程池的简单运用Executors.newFixedThreadPool
weixin_46649054的博客
08-05 7455
/** * https://blog.csdn.net/weixin_40271838/article/details/79998327 * * 通过运行结果，可以看到我们创建了一个固定数量为2的FixedThreadPool，所以第3个任务会进入等待队列，因为核心线程不够用了，而当有任务经过6s的时间执行完后，有了空闲线程，那么第3个任务就可以接着执行了 */ public class TestMain { //格式化 static SimpleDateFormat sim = n
自定义线程池
weixin_45080497的博客
02-20 826
线程池:使用ThreadPoolProperties对ThreadPoolConfiguration配置类进行改造。
线程池-newFixedThreadPool
Flying_Fish_roe的博客
10-12 2690
是 Java 中一种常用的线程池创建方式，它创建了一个固定大小的线程池，适合处理负载稳定、需要控制并发数量的场景。通过限制线程池中的线程数量，可以有效控制系统资源的使用，避免因线程过多导致的性能下降。
Java自定义线程池
今天又是充满希望的一天
02-20 1万+
一、Java语言本身也是多线程，回顾Java创建线程方式如下： 1、继承Thread类,(Thread类实现Runnable接口)，来个类图加深印象。 2、实现Runnable接口实现无返回值、实现run()方法，啥时候run，黑话了。 3、实现Callable接口重写call()+FutureTask获取. public class CustomThread { public static void main(String[] args) { // 自定义线程 .
Java自带的线程池Executors.newFixedThreadPool
tengtianshan的专栏
10-24 4110
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。  　　在Java5之前，要实现一个线程池是相当有难度的，现在Java5为我们做好了一切，我们只需要按照提供的API来使用，即可享受线程池带来的极大便利。  ...
线程池Executors.newFixedThreadPool验证以及总结
weixin_42394615的博客
09-14 2万+
1、Executors在于java.util.comcurrent.包下，Executors.newFixedThreadPool(n)创建容器大小为n的线程池，表示正在执行中的线程只有n个， 实践代码如下： public class TestExecute { public static void main(String[] args) { Executor ex...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值