java线程池

最新推荐文章于 2025-04-08 10:33:06 发布
最新推荐文章于 2025-04-08 10:33:06 发布
阅读量642 收藏
点赞数
分类专栏： java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/huangquan__/article/details/117336817
版权

线程池


在这里插入图片描述

1. 为什么要用线程池？有什么优势？

在这里插入图片描述
例子:
10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。现在是多核电脑，多个线程各自跑在独立的CPU上，不用切换效率高。

线程池的优势:

线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

它的主要特点为:

线程复用;控制最大并发数;管理线程。
第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
第二:提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。
第三:提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

二级目录

三级目录

2.线程池如何使用：

线程池的三大方法：

在这里插入图片描述
在这里插入图片描述

1. Executors.newFixedThreadPool(5)

在这里插入图片描述

package JUCTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 
 * @author fly
 *
 */
public class MyThreadPoolDemo26 {
	public static void main(String[] args) {
		ExecutorService threadPool = Executors.newFixedThreadPool(5);//五个工作线程的线程池（固定的）
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
	}
}
************************
pool-1-thread-3  办理业务
pool-1-thread-1  办理业务
pool-1-thread-4  办理业务
pool-1-thread-5  办理业务
pool-1-thread-2  办理业务
pool-1-thread-5  办理业务
pool-1-thread-4  办理业务
pool-1-thread-1  办理业务
pool-1-thread-3  办理业务
pool-1-thread-2  办理业务

2.Executors.newSingleThreadExecutor();//只有单个工作线程的线程池

在这里插入图片描述

ExecutorService threadPool = Executors.newSingleThreadExecutor();//只有单个工作线程的线程池
		
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
**********************************************************
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务
pool-1-thread-1  办理业务

3.Executors.newCachedThreadPool()：//线程数课扩容的线程池(带缓存的线程池)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

ExecutorService threadPool = Executors.newCachedThreadPool();//线程数课扩容的线程池(带缓存的线程池)
		
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}

3.线程池的七大重要参数：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
1、corePoolSize:线程池中的常驻核心线程数；
2、maximumPoolSize:线程池中能够容纳同时执行的最大线程数，此值必须大于等于1；
3、keepAliveTime:多余的空闲线程的存活时间当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程为止；
4、unit: keepAliveTime的单位；
5、workQueue:任务队列，被提交但尚未被执行的任务；
6、threadFactory:表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可；
7、handler:拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数(maximumPoolSize）时如何来拒绝请求执行的runnable的策略；

/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

4.线程池底层工作原理：

三大方法的底层：

Executors.newFixedThreadPool(5)：

在这里插入图片描述

Executors.newSingleThreadExecutor()：

在这里插入图片描述

Executors.newCachedThreadPool()：

在这里插入图片描述

本质

三个生成线程池的方法底层调用的都是同一个方法：new ThreadPoolExecutor();只是传的参数不同。
在这里插入图片描述

原理：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
正在执行的线程数等于CorePooleSize，且阻塞队列也满员了，此时如果还有任务进来，name就会开始扩容，增加CorePooleSize的大小，扩容到CorePooleSize达到maxiumPoolSize，之后线程池不再开启新的线程，而是采用拒绝策略，不再允许新的任务使用线程池
扩容：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
1、在创建了线程池后，开始等待请求。
2、当调用execute()方法添加一个请求任务时，线程池会做出如下判断:
2.1如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务;
2.2如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列;
2.3如果这个时候队列满了且正在运行的线程数量还小于maximumPoo1Size，那么还是 要创建非核心线程立刻运行这个任务;
2.4如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会 启动饱和拒绝策略来执行。
3、当一个线程完成任务时，它会从队列中取下一个任务来执行。
4、当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断:
如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。

5.如何手撕线程池？以及定义参数？

如何创建线程池：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

最大执行任务的数量：maximumPoolSize+阻塞队列的长度
超过则抛出异常：拒绝执行异常：java.util.concurrent.RejectedExecutionException

代码：

public class MyThreadPoolDemo26 {
	
	public static void main(String[] args) {
		System.out.println("CPU处理器数（内核）："+Runtime.getRuntime().availableProcessors());
		ExecutorService threadPool = new ThreadPoolExecutor(2, //核心数
															5, //最大线程数     CPU密集型电脑  一般设置值为：比电脑核数多1或者2   I/O密集型电脑：一般设置为：1除以核数除以阻塞系数 
															2L, //扩容线程的最大活跃时间（等待时间）
															TimeUnit.SECONDS, //时间格式
															new LinkedBlockingDeque<Runnable>(3),//阻塞队列//如果不指名队列大小，则默认Integer.MAXVALUE
															Executors.defaultThreadFactory(),//线程工厂
															new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策略
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
//				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
		
		
		
	}
}

6.拒绝策略：

在这里插入图片描述
在这里插入图片描述

1.AbortPolicy()：默认策略。

在这里插入图片描述
在这里插入图片描述

2.CallerRunsPolicy():

在这里插入图片描述
在这里插入图片描述

3.DiscardPolicy():

十个任务，抛弃了两个，只执行了八个（最大任务量）
在这里插入图片描述
在这里插入图片描述

4.DiscardOldestPolicy():

抛弃等待队列中等待时间最长的任务
在这里插入图片描述
在这里插入图片描述

代码：

public class MyThreadPoolDemo26 {
	
	public static void main(String[] args) {
		System.out.println("CPU处理器数（内核）："+Runtime.getRuntime().availableProcessors());
		ExecutorService threadPool = new ThreadPoolExecutor(2, //核心数
															5, //最大线程数     CPU密集型电脑  一般设置值为：比电脑核数多1或者2   I/O密集型电脑：一般设置为：1除以核数除以阻塞系数 
															2L, //扩容线程的最大活跃时间（等待时间）
															TimeUnit.SECONDS, //时间格式
															new LinkedBlockingDeque<Runnable>(3),//阻塞队列//如果不指名队列大小，则默认Integer.MAXVALUE
															Executors.defaultThreadFactory(),//线程工厂
															new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策略（可以修改）
															//new ThreadPoolExecutor.AbortPolicy();
															//new ThreadPoolExecutor.CallerRunsPolicy();
															//new ThreadPoolExecutor.DiscardPolicy();
		try {
			//模拟有10个顾客来银行办理业务，目前银行里面有5个工作人员提供服务
			for(int i = 1;i <= 10;i++) {
				threadPool.execute(()->{
					System.out.println(Thread.currentThread().getName()+"  办理业务");
				});
//				TimeUnit.MILLISECONDS.sleep(100L);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			threadPool.shutdown();//关闭线程池
		}
		
		
	}
		
}
线程池使用
天才周的博客
08-21 272
线程池： 多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。 假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。 如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。 一个线程池包括以...
Java线程池ThreadPoolExecutor背后的秘密与实践
热门推荐
张彦峰的博客
05-12 169万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
线程池的使用
人生不设限，高飞吧~
12-03 4764
在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用Thread的start（）更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。 　　一、创建任务 　　任务就是一个实现了Runnable接口的类。 　　创建的时候实run方法即可。
线程池的使用-线程池的使用
afssa的博客
08-18 282
线程池的使用 线程资源不应该直接使用，不应该在程序中显式使用，而应该由线程池提供 1、使用线程池的优势 （1）使用new Thread 创建线程有较大的弊端 1 .每次使用线程都需要new Thread（）创建对象性能较差 2 .线程缺少管理，可能会无限创建线程，导致系统死机及oom 3.线程功能单一，缺少其他设置 （2）线程池的优势 （1）、大幅度降低资源消耗，复用线程池中线程，避免线程创建和销毁的操作 节约时间和间隔； （2）、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创.
各种线程池的使用
最新发布
qq_56650001的博客
04-08 695
ThreadPoolExecutor、ThreadPoolTaskExecutor、CompletableFuture
java线程池使用后到底要关闭吗
08-26
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...
java线程池实现批量下载文件
08-25
Java线程池实现批量下载文件 Java线程池实现批量下载文件是指使用Java语言和线程池机制来实现批量下载文件的功能。这种方法可以大幅提高下载速度和效率，特别是当需要下载大量文件时。下面将对Java线程池实现批量...
java线程池源码-cThreadPool:JAVA线程池源码分析与重写
05-25
java线程池源码 cThreadPool 项目描述：对java.util.concurrent包下线程池相关源码进行重新实现，深入研究和学习线程池超时机制、饱和策略、生命周期等知识 ThreadPoolExecutor类下部分方法和内部类介绍： 1、Worker...
java线程池处理多并发，所有进程执行完后再统一处理结果
01-21
java线程池处理多并发，所有进程执行完后再统一处理结果线程池配置类多线程并行demo 线程池配置类 import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation....
java多线程详解(7)-线程池的使用
weixin_30687811的博客
09-16 263
在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了， 这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 这个是时候我们需要使用线程池技术创建多线程。 本文目录大纲： 一.Java中的ThreadPoolExecutor类 二.深入剖析线程池实现...
Java线程池
03-21
好的，我现在需要向用户介绍Java线程池。首先，我应该回忆一下线程池的基本概念和作用，然后考虑Java中线程池的具体实现方式。用户可能想知道为什么使用线程池，线程池有什么好处，以及如何在实际项目中使用。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值