Java线程池讲义
java线程池的使用例子
java线程池的使用例子随着计算机技术的不断发展，我们的软件系统越来越复杂，程序的性能要求也越来越高。
在这样的背景下，线程池成为了一种非常重要的工具。
Java线程池是Java提供的一种简单易用的线程管理工具，可以帮助我们更好地管理程序中的线程，提高程序的性能和稳定性。
本文将通过一个实际的例子来介绍Java线程池的使用方法和注意事项。
希望读者可以通过本文的学习，更好地掌握Java线程池的使用技巧。
一、什么是线程池？在介绍Java线程池之前，我们需要先了解什么是线程池。
线程池是一种管理线程的机制，可以帮助我们更好地管理程序中的线程，提高程序的性能和稳定性。
线程池的主要作用是为每个任务分配一个线程，当任务完成后，线程会被回收并可供下一个任务使用。
这样，线程的创建和销毁的开销就可以得到控制，避免了频繁创建和销毁线程所带来的性能损失。
二、Java线程池的使用方法1. 创建线程池Java线程池的创建方式非常简单，只需要使用ThreadPoolExecutor类即可。
以下是一个简单的线程池创建代码： ```ExecutorService executor =Executors.newFixedThreadPool(5);```这个代码创建了一个固定大小为5的线程池。
如果需要创建其他类型的线程池，可以使用其他的静态工厂方法，如newCachedThreadPool()、newSingleThreadExecutor()等。
2. 提交任务创建好线程池之后，我们就可以向线程池提交任务了。
以下是一个简单的线程池提交任务代码：```executor.submit(new Runnable() {@Overridepublic void run() {// 执行任务}});```这个代码提交了一个Runnable类型的任务，线程池会自动为其分配一个线程执行。
如果需要提交其他类型的任务，可以使用Callable、Future等接口。
Java框架中的线程池管理策略
Java框架中的线程池管理策略在Java框架中，线程池是一种常用的资源调度和管理机制，能够有效地管理和重用线程资源，提高应用程序的性能和并发处理能力。
本文将介绍Java框架中常用的线程池管理策略，并分析其适用场景和特点。
一、固定大小线程池（FixedThreadPool）固定大小线程池是一种最基础的线程池管理策略，它通过设定一个固定大小的线程池来管理线程资源。
在创建线程池时，会预先创建指定数量的线程，并将任务按顺序依次分配给这些线程进行执行。
当线程池中的线程被占满时，新的任务将会被暂存，等待有空闲线程可用时再执行。
固定大小线程池适用于负载相对稳定的场景，可以有效控制系统资源的使用。
二、缓存线程池（CachedThreadPool）缓存线程池是一种根据需要自动调整线程池大小的管理策略。
它会根据任务的数量自动调整线程池的大小，当任务增加时会自动扩大线程池，当任务减少时会自动缩小线程池。
这种策略适用于任务数波动较大的场景，能够更加灵活地管理线程资源，避免资源的浪费。
三、单线程线程池（SingleThreadExecutor）单线程线程池是一种只有一个线程的线程池管理策略。
它会按顺序执行每个任务，并保证所有任务都是按照添加的顺序执行的。
当某个任务执行失败时，会创建一个新线程来代替原来的线程继续执行后续任务。
单线程线程池适用于需要按顺序执行任务，并且任务间存在依赖关系的场景。
四、定时线程池（ScheduledThreadPool）定时线程池是一种可以定时执行任务的线程池管理策略。
它允许设置任务的执行时间和执行周期，可以在固定的时间间隔内周期性地执行任务。
定时线程池适用于需要按照一定的时间规律执行任务的场景，如定时任务调度、定期数据备份等。
五、工作窃取线程池（WorkStealingPool）工作窃取线程池是Java8新增的一种线程池管理策略。
它基于工作窃取算法，允许线程动态地从其他线程的任务队列中窃取任务执行，实现了任务的负载均衡。
java threadpoolexecutor用法 -回复
java threadpoolexecutor用法-回复Java ThreadPoolExecutor是Java中用于管理线程池的一个类。
线程池可以提高多线程任务的执行效率，通过复用线程对象、控制并发线程数量和管理任务队列，能够更好地处理大量并发请求。
在本文中，我们将详细介绍ThreadPoolExecutor的用法和功能，以帮助开发者更好地使用它来处理多线程任务。
首先，我们需要了解ThreadPoolExecutor的基本概念和组成。
ThreadPoolExecutor是Executor框架的一个具体实现类，它利用一个线程池来执行指定的任务。
线程池由一组线程、任务队列和执行器组成。
线程池中的线程是预先创建的，它们可以被重复使用来执行多个任务。
任务队列用于存储待执行的任务，当线程池中的线程空闲时，它们会从任务队列中取出任务进行处理。
执行器用于控制任务的提交和执行。
接下来，我们将详细介绍ThreadPoolExecutor的构造函数和相关方法。
ThreadPoolExecutor的构造函数可以根据需要来创建一个线程池对象，它提供了多个参数来配置线程池的行为。
下面是ThreadPoolExecutor的构造函数和参数说明：javapublic ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)- corePoolSize：线程池的核心线程数量，即在没有任务需要执行时线程池中保留的线程数量。
- maximumPoolSize：线程池的最大线程数量，允许创建的最大线程数。
- keepAliveTime：当线程池中的线程数量大于核心线程数时，多余的空闲线程在终止之前等待新任务的最长时间。
javaspringboot线程池以及多线程
javaspringboot线程池以及多线程线程和进程进程是资源分配的最⼩单位，线程是CPU调度的最⼩单位。
是不是很抽象，做个简单⽐喻，进程=⽕车，线程=车厢，线程在进程⾥运⾏（单个的车厢是⽆法运⾏的）；不同进程之间数据很难共享，同⼀进程下的线程数据共享则很容易。
多线程⼀个应⽤程序有多条执⾏路径（单线程：⼀个应⽤程序只有⼀条执⾏路径）。
应⽤场景异步，有些功能⽆需同步执⾏，可以使⽤另外⼀个线程去执⾏。
多个线程共同完成⼀个事情，缩短整体执⾏时间，同时cpu也得到了充分利⽤（例如，盖房⼦垒墙，⼀个⼈需要10天，10个⼈同时做，1天左右可以完成）。
线程池什么是线程池线程池，顾名思义，是存放了⼀堆线程的池⼦/容器，并且管理线程的整个⽣命周期。
java.util.concurrent.Executors提供了⼀个 java.util.concurrent.Executor接⼝的实现⽤于创建线程池。
为什么要⽤线程池1. 减少了创建和销毁线程的次数，每个⼯作线程都可以被重复利⽤，可执⾏多个任务。
2. 可以根据系统的承受能⼒，调整线程池中⼯作线线程的数⽬，防⽌因为消耗过多的内存，⽽把服务器累趴下(每个线程需要⼤约1MB内存，线程开的越多，消耗的内存也就越⼤，最后死机)。
实现⽅式此处以springboot实现⽅式为例import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.annotation.EnableAsync;import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import java.util.concurrent.Executor;import java.util.concurrent.ThreadPoolExecutor;/*** @author lipeiguang*/@Configuration@EnableAsyncpublic class ThreadPoolConfig {@Bean(name = "executor")public Executor getAsyncThread() {ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();//线程池维护线程的最少数量taskExecutor.setCorePoolSize(5);//线程池维护线程的最⼤数量,只有在缓冲队列满了之后才会申请超过核⼼线程数的线程taskExecutor.setMaxPoolSize(10);//缓存队列taskExecutor.setQueueCapacity(20);//允许的空闲时间,当超过了核⼼线程出之外的线程在空闲时间到达之后会被销毁taskExecutor.setKeepAliveSeconds(200);//线程名称前缀taskExecutor.setThreadNamePrefix("my-thread-");// 线程池对拒绝任务（⽆线程可⽤）的处理策略，⽬前只⽀持AbortPolicy、CallerRunsPolicy；默认为后者taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());// 调度器shutdown被调⽤时等待当前被调度的任务完成taskExecutor.setWaitForTasksToCompleteOnShutdown(true);// 等待时长taskExecutor.setAwaitTerminationSeconds(60);taskExecutor.initialize();return taskExecutor;}}其中的corePoolSize设置参考：N为cpu个数如果是CPU密集型应⽤，则线程池⼤⼩设置为N+1如果是IO密集型应⽤，则线程池⼤⼩设置为2N+1cpu个数查询⽅式：Runtime.getRuntime().availableProcessors()；linux查询⽅式：cat /proc/cpuinfo| grep"processor"| wc -l使⽤线程池实现异步import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import javax.annotation.Resource;import java.util.concurrent.Executor;/*** 使⽤demo* @author lipeiguang*/@Slf4j@Api(tags = {"异步线程测试"})@RestControllerpublic class ExecutorDemo {//使⽤时通过注解/*** 如果是多线程，可以直接使⽤这个executor*/@Resource(name = TaskExecutorConstant.SALARY_TASK_EXECUTOR) private Executor executor;@Autowiredprivate ServiceDemo serviceDemo;@ApiOperation("异步测试")@GetMapping("/test/async")public String testAsync(){("主线程开始执⾏。
java定时器线程池（ScheduledThreadPoolExecutor）的实现
java定时器线程池（ScheduledThreadPoolExecutor）的实现前⾔定时器线程池提供了定时执⾏任务的能⼒，即可以延迟执⾏，可以周期性执⾏。
但定时器线程池也还是线程池，最底层实现还是ThreadPoolExecutor，可以参考我的另外⼀篇⽂章多线程–精通ThreadPoolExecutor。
特点说明1.构造函数public ScheduledThreadPoolExecutor(int corePoolSize) {// 对于其他⼏个参数在ThreadPoolExecutor中都已经详细分析过了，所以这⾥,将不再展开// 这⾥我们可以看到调⽤基类中的⽅法时有个特殊的⼊参DelayedWorkQueue。
// 同时我们也可以发现这⾥并没有设置延迟时间、周期等参数⼊⼝。
// 所以定时执⾏的实现必然在DelayedWorkQueue这个对象中了。
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,new DelayedWorkQueue());}2.DelayedWorkQueueDelayedWorkQueue是在ScheduledThreadPoolExecutor的⼀个内部类，实现了BlockingQueue接⼝⾥⾯存放任务队列的数组如下：private RunnableScheduledFuture<?>[] queue =new RunnableScheduledFuture<?>[INITIAL_CAPACITY];我们分析过ThreadPoolExecutor，它从任务队列中获取任务的⽅式为poll和take两种，所以看⼀下poll和take两个⽅法的源码，回顾⼀下，ThreadPoolExecutor它会调⽤poll或take⽅法，先poll，再take，只要其中⼀个接⼝有返回就⾏public RunnableScheduledFuture<?> poll() {final ReentrantLock lock = this.lock;lock.lock();try {RunnableScheduledFuture<?> first = queue[0];// 这⾥有个getDelay，这是关键点，获取执⾏延时时间// 但是如果我们有延时设置的话，这就返回空了，然后就会调⽤take⽅法if (first == null || first.getDelay(NANOSECONDS) > 0)return null;elsereturn finishPoll(first);} finally {lock.unlock();}}public RunnableScheduledFuture<?> take() throws InterruptedException {final ReentrantLock lock = this.lock;lock.lockInterruptibly();try {for (;;) {RunnableScheduledFuture<?> first = queue[0];if (first == null)available.await();else {// 获取延时时间long delay = first.getDelay(NANOSECONDS);if (delay <= 0)return finishPoll(first);first = null; // don't retain ref while waitingif (leader != null)available.await();else {Thread thisThread = Thread.currentThread();leader = thisThread;try {// 使⽤锁，执⾏延时等待。
JAVA自定义线程池的最大线程数设置方法
JAVA自定义线程池的最大线程数设置方法一、Java自定义线程池的作用线程池是一个减少在应用程序中创建和销毁线程的机制，它可以对线程进行重用，使线程池可以解决多线程同步的问题，提高程序服务能力，减少资源消耗，提高程序效率。
二、Java自定义线程池的原理创建线程池时，它会先创建固定数量的线程（拒绝政策），并将它们放入空闲队列中，当有任务需要处理时，会从队列中取出一个空闲线程来处理，有可能是一个新线程也可能是一个已存在的线程，比如，如果空闲队列中还有可用的线程，就会重新使用这些线程，而不会重新创建新的线程；如果空闲队列为空，则会创建新的线程来处理任务。
当一个线程处理完任务后，它会被重新放入空闲队列等待下一次处理任务。
如果空闲队列中线程数量超过了最大线程数，则这些空闲线程会被终止。
三、自定义线程池的最大线程数设置1.通过ThreadPoolExecutor.Builder类中的maximumPoolSize方法来设置最大线程数ThreadPoolExecutor.Builder builder = new ThreadPoolExecutor.Builder(;builder.maximumPoolSize(maxThreads);2.通过ThreadPoolExecutor类中的setMaximumPoolSize方法来设置最大线程数ThreadPoolExecutor executor = new ThreadPoolExecutor(; executor.setMaximumPoolSize(maxThreads);3.通过Executors类下的有参方法来设置最大线程数Executors.newFixedThreadPool(maxThreads);4.通过自定义ThreadPoolExecutor类来设置最大线程数public class MyThreadPoolExecutor extends ThreadPoolExecutor private int maxThreads;。
java threadpoolexecutor 参数
java threadpoolexecutor 参数【原创实用版】目录1.Java 线程池概述2.ThreadPoolExecutor 参数介绍3.ThreadPoolExecutor 参数的具体用法和配置4.ThreadPoolExecutor 参数对线程池性能的影响5.总结正文一、Java 线程池概述Java 线程池（ThreadPoolExecutor）是 Java 并发编程中常用的一种线程管理工具，它能够有效地重用线程，减少线程的创建和销毁的开销，提高程序的执行效率。
线程池可以分为固定线程数量的线程池和可调整线程数量的线程池，其中可调整线程数量的线程池又分为两种：一种是线程数量固定的线程池，另一种是线程数量动态调整的线程池。
二、ThreadPoolExecutor 参数介绍ThreadPoolExecutor 是 Java 线程池的实现类，它提供了一系列的参数来配置线程池，这些参数主要包括：1.核心线程数（corePoolSize）：线程池中的核心线程数量，即线程池中最少需要保持的线程数量。
当线程池中的线程数量小于corePoolSize 时，线程池会自动创建新的线程。
2.最大线程数（maxPoolSize）：线程池中的最大线程数量。
当线程池中的线程数量达到 maxPoolSize 时，线程池将不再创建新的线程。
3.队列容量（queueCapacity）：线程池中的任务队列容量。
当线程池中的线程数量达到 maxPoolSize，且任务队列已满时，线程池将拒绝新的任务。
4.拒绝策略（rejectedExecutionHandler）：当线程池无法执行新任务时，可以采用的拒绝策略。
常用的拒绝策略有：AbortPolicy（默认策略，直接抛出异常）、CallerRunsPolicy（让调用者执行任务）、DiscardPolicy（直接丢弃任务，不抛出异常）和 DiscardOldestPolicy （丢弃队列中最旧的任务，然后尝试执行新任务）。
6、java5线程池之固定大小线程池newFixedThreadPool
6、java5线程池之固定⼤⼩线程池newFixedThreadPoolJDK⽂档说明：创建⼀个可重⽤固定线程数的线程池，以共享的⽆界队列⽅式来运⾏这些线程。
在任意点，在⼤多数 nThreads 线程会处于处理任务的活动状态。
如果在所有线程处于活动状态时提交附加任务，则在有可⽤线程之前，附加任务将在队列中等待。
如果创建⽅法：java.util.concurrent.Executors.newFixedThreadPool(int nThreads)orjava.util.concurrent.Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory)调⽤上⾯2个⽅法得到的对象为：ExecutorServiceJDK⾃带的例⼦：下⾯给出了⼀个⽹络服务的简单结构，这⾥线程池中的线程作为传⼊的请求。
它使⽤了预先配置的Executors.newFixedThreadPool(int)⼯⼚⽅法：class NetworkService implements Runnable {private final ServerSocket serverSocket;private final ExecutorService pool;public NetworkService(int port, int poolSize) throws IOException {serverSocket = new ServerSocket(port);pool = Executors.newFixedThreadPool(poolSize);}public void run() { // run the servicetry {for (;;) {pool.execute(new Handler(serverSocket.accept()));}} catch (IOException ex) {pool.shutdown();}}}class Handler implements Runnable {private final Socket socket;Handler(Socket socket) { this.socket = socket; }public void run() {// read and service request on socket}}主要的⽅法：boolean awaitTermination(long timeout, TimeUnit unit)请求关闭、发⽣超时或者当前线程中断，⽆论哪⼀个⾸先发⽣之后，都将导致阻塞，直到所有任务完成执⾏。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
java内置线程池 自定义线程池 异步计算结果(Future)
2.1Java内置线程池介绍
Java内置线程池原理剖析
我们要想自定义线程池,必须先了解线程池的工作原理,才能自己定义线程池； 这里我们通过观察java中ThreadPoolExecutor的源码来学习线程池的原理; (源码演示在idea中查看)
1.3使用线程池有哪些优势
使用线程池有哪些优势
1:线程和任务分离,提升线程重用性; 2:控制线程并发数量,降低服务器压力,统一管理所有线程; 3:提升系统响应速度,假如创建线程用的时间为T1，执行任务用的时间为T2,销毁线 程用的时间为T3，那么使用线程池就免去了T1和T3的时间；
1.4:线程池应用场景介绍
线程池中的所有线程都使用ThreadFactory来创建,这样的线程无需手动启动,自动执行; static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池 static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
延迟时间单位是unit,数量是delay的时间后执行callable。 ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
2.3:Java内置线程池-ExecutorService介绍
ExecutorService接口是java内置的线程池接口,通过学习接口中的方法,可以快速的掌握java内置线程池的基本使用 常用方法: void shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。 List<Runnable> shutdownNow() 停止所有正在执行的任务，暂停处理正在等待的任务，并返回等待执行的任务列表。 <T> Future<T> submit(Callable<T> task) 执行带返回值的任务，返回一个Future对象。 Future<?> submit(Runnable task) 执行 Runnable 任务，并返回一个表示该任务的 Future。 <T> Future<T> submit(Runnable task, T result) 执行 Runnable 任务，并返回一个表示该任务的 Future。
创建一个可重用固定线程数的线程池且线程池中的所有线程都使用ThreadFactory来创建。 static ExecutorService newSingleThreadExecutor()
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。 static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) 创建一个使用单个 worker 线程的 Executor，且线程池中的所有线程都使用ThreadFactory来创建。
2.1.3:线程池工作流程总结示意图
2.2:自定义线程池-参数设计分析
通过观察Java中的内置线程池参数讲解和线程池工作流程总结,我们不难发现,要设计一个好的线程池, 就必须合理的设置线程池的4个参数;那到底该如何合理的设计4个参数的值呢?我们一起往下看.
2.2.1:4个参数的设计: 1:核心线程数(corePoolSize)
1.1 什么是线程池
什么是池
1.1 什么是线程池
什么是线程池
线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后 在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程,这里的任务 就是我们前面学过的实现了Runnable或Callable接口的实例对象;
1.2为什么使用线程池
创建一个单线程执行程序，它允许在给定延迟后运行命令或者定期地执行。 static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
应用场景介绍 1:网购商品秒杀 2:云盘文件上传和下载 3:12306网上购票系统等
总之 只要有并发的地方、任务数量大或小、每个任务执行时间长或短的都可以使用线程池; 只不过在使用线程池的时候,注意一下设置合理的线程池大小即可;(关于如何合理设置线 程池大小在后面的章节中讲解)
线程池使用
目
Contents
思考: 既然ExecutorService是一个接口,接口是无法直接创建对象的,那么我们该如何获取ExecutorService的对象呢?
2.3:Java内置线程池-ExecutorService获取
获取ExecutorService可以利用JDK中的Executors 类中的静态方法,常用获取方式如下: static ExecutorService newCachedThreadPool() 创建一个默认的线程池对象,里面的线程可重用,且在第一次使用时才创建 static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
为什么使用线程池
1.2为什么使用线程池
为什么使用线程池
使用线程池最大的原因就是可以根据系统的需求和硬件环境灵活的控制线程的数量, 且可以对所有线程进行统一的管理和控制,从而提高系统的运行效率,降低系统运行运 行压力;当然了,使用线程池的原因不仅仅只有这些,我们可以从线程池自身的优点上 来进一步了解线程池的好处;
2.1.1:ThreadPoolExecutor部分源码
昨构日造复方习法:
public ThreadPoolExecutor(int corePoolSize, //核心线程数量
int maximumPoolSize,// 最大线程数
long keepAliveTime, // 最大空闲时间
TimeUnit unit,
1:编写任务类(MyTask),实现Runnable接口; 2:编写线程类(MyWorker),用于执行任务,需要持有所有任务; 3:编写线程池类(MyThreadPool),包含提交任务,执行任务的能力; 4:编写测试类(MyTest),创建线程池对象,提交多个任务测试; 具体代码参考idea
小提示: 关于线程池的功能比较繁多,这里仅仅模拟了核心功能,其他功能大家可以自行思考补全;
(代码演示参考idea)
2.3:Java内置线程池-ScheduledExecutorService
ScheduledExecutorService是ExecutorService的子接口,具备了延迟运行或定期执行任务的能力, 常用获取方式如下: static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
4:最大空闲时间(keepAliveTime)
这个参数的设计完全参考系统运行环境和硬件压力设定,没有固定的参考值,用户可以根据经验和系统产生任务的时间间隔合理 设置一个值即可;
小提示:
上面4个参数的设置只是一般的设计原则,并不是固定的,用户也可以根据实际情况灵活调整!
2.2:自定义线程池-实现步骤
// 时间单位
BlockingQueue<Runnable> workQueue, // 任务队列
ThreadFactory threadFactory, // 线程工厂
RejectedExecutionHandler handler // 饱和处理机制
)
{ ... }
2.1.2:ThreadPoolExecutor参数详解
核心线程数的设计需要依据任务的处理时间和每秒产生的任务数量来确定,例如:执行一个任务需要0.1秒,系统百分之80的时间每 秒都会产生100个任务,那么要想在1秒内处理完这100个任务,就需要10个线程,此时我们就可以设计核心线程数为10;当然实际情况不可能这么平 均,所以我们一般按照8020原则设计即可,既按照百分之80的情况设计核心线程数,剩下的百分之20可以利用最大线程数处理;
2.3:Java内置线程池-ScheduledExecutorService
ScheduledExecutorService常用方法如下: <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
目标
TARGET
【理解】线程池基本概念 【理解】线程池工作原理 【掌握】自定义线程池 【应用】java内置线程池 【应用】使用java内置线程池完成综合案例
Contents
目
Hale Waihona Puke 线程池1. 线程池基础 2. 线程池使用 3. 线程池综合案例 4.学员练习 5.线程池总结
线程池基础
概念介绍 1:什么是线程池 2:为什么使用线程池 3:线程池有哪些优势
我们可以通过下面的场景理解ThreadPoolExecutor中的各个参数;
昨日复习
a客户(任务)去银行(线程池)办理业务,但银行刚开始营业,窗口服务员还未就位(相当于线程池中初始线程数量为0), 于是经理(线程池管理者)就安排1号工作人员(创建1号线程执行任务)接待a客户(创建线程); 在a客户业务还没办完时,b客户(任务)又来了,于是经理(线程池管理者)就安排2号工作人员(创建2号线程执行任务)接待b客户(又创建了一个新的线程); 假设该银行总共就2个窗口(核心线程数量是2); 紧接着在a,b客户都没有结束的情况下c客户来了,于是经理(线程池管理者)就安排c客户先坐到银行大厅的座位上(空位相当于是任务队列)等候, 并告知他: 如果1、2号工作人员空出,c就可以前去办理业务; 此时d客户又到了银行,(工作人员都在忙,大厅座位也满了)于是经理赶紧安排临时工(新创建的线程)在大堂站着,手持pad设备给d客户办理业务; 假如前面的业务都没有结束的时候e客户又来了,此时正式工作人员都上了,临时工也上了,座位也满了(临时工加正式员工的总数量就是最大线程数), 于是经理只能按《超出银行最大接待能力处理办法》(饱和处理机制)拒接接待e客户; 最后,进来办业务的人少了,大厅的临时工空闲时间也超过了1个小时(最大空闲时间),经理就会让这部分空闲的员工人下班.(销毁线程) 但是为了保证银行银行正常工作(有一个allowCoreThreadTimeout变量控制是否允许销毁核心线程,默认false),即使正式工闲着,也不得提前下班,所 以1、2号工作人员继续待着(池内保持核心线程数量);