线程池详解（通俗易懂超级好）

article/2025/9/10 8:31:15

目标

【理解】线程池基本概念
【理解】线程池工作原理
【掌握】自定义线程池
【应用】java内置线程池
【应用】使用java内置线程池完成综合案例

线程池

  1. 线程池基础
  2. 线程池使用
  3. 线程池综合案例
  4. 学员练习
  5. 线程池总结

概念介绍

  1. 什么是线程池
  2. 为什么使用线程池
  3. 线程池有哪些优势

什么是池

在这里插入图片描述

什么是线程池

线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程,这里的任务就是我们前面学过的实现了Runnable或Callable接口的实例对象;

为什么使用线程池

使用线程池最大的原因就是可以根据系统的需求和硬件环境灵活的控制线程的数量,且可以对所有线程进行统一的管理和控制,从而提高系统的运行效率,降低系统运行运行压力;当然了,使用线程池的原因不仅仅只有这些,我们可以从线程池自身的优点上来进一步了解线程池的好处;

使用线程池有哪些优势

  1. 线程和任务分离,提升线程重用性;
  2. 控制线程并发数量,降低服务器压力,统一管理所有线程;
  3. 提升系统响应速度,假如创建线程用的时间为T1，执行任务用的时间为T2,销毁线程用的时间为T3，那么使用线程池就免去了T1和T3的时间；

线程池应用场景介绍

应用场景介绍
1. 网购商品秒杀
2. 云盘文件上传和下载
3. 12306网上购票系统等

总之
只要有并发的地方、任务数量大或小、每个任务执行时间长或短的都可以使用线程池;
只不过在使用线程池的时候,注意一下设置合理的线程池大小即可;(关于如何合理设置线程池大小在后面的章节中讲解)

java内置线程池
自定义线程池
异步计算结果(Future)

Java内置线程池原理剖析

我们要想自定义线程池,必须先了解线程池的工作原理,才能自己定义线程池；
这里我们通过观察java中ThreadPoolExecutor的源码来学习线程池的原理;
(源码演示在idea中查看)

ThreadPoolExecutor部分源码

构造方法:
public ThreadPoolExecutor(int corePoolSize, //核心线程数量int maximumPoolSize,//     最大线程数long keepAliveTime, //       最大空闲时间TimeUnit unit,         //        时间单位BlockingQueue<Runnable> workQueue,   //   任务队列ThreadFactory threadFactory,    // 线程工厂RejectedExecutionHandler handler  //  饱和处理机制) 
{ ... }

ThreadPoolExecutor参数详解

我们可以通过下面的场景理解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号工作人员继续待着(池内保持核心线程数量);

线程池工作流程总结示意图

在这里插入图片描述

自定义线程池-参数设计分析

通过观察Java中的内置线程池参数讲解和线程池工作流程总结,我们不难发现,要设计一个好的线程池,就必须合理的设置线程池的4个参数;那到底该如何合理的设计4个参数的值呢?我们一起往下看.

4个参数的设计:

1:核心线程数(corePoolSize)
核心线程数的设计需要依据任务的处理时间和每秒产生的任务数量来确定,例如:执行一个任务需要0.1秒,系统百分之80的时间每秒都会产生100个任务,那么要想在1秒内处理完这100个任务,就需要10个线程,此时我们就可以设计核心线程数为10;当然实际情况不可能这么平均,所以我们一般按照8020原则设计即可,既按照百分之80的情况设计核心线程数,剩下的百分之20可以利用最大线程数处理;
2:任务队列长度(workQueue)
任务队列长度一般设计为:核心线程数/单个任务执行时间*2即可;例如上面的场景中,核心线程数设计为10,单个任务执行时间为0.1秒,则队列长度可以设计为200;
3:最大线程数(maximumPoolSize)
最大线程数的设计除了需要参照核心线程数的条件外,还需要参照系统每秒产生的最大任务数决定:例如:上述环境中,如果系统每秒最大产生的任务是1000个,那么,最大线程数=(最大任务数-任务队列长度)*单个任务执行时间;既: 最大线程数=(1000-200)*0.1=80个;
4:最大空闲时间(keepAliveTime)
这个参数的设计完全参考系统运行环境和硬件压力设定,没有固定的参考值,用户可以根据经验和系统产生任务的时间间隔合理设置一个值即可;

自定义线程池-实现步骤

1:编写任务类(MyTask),实现Runnable接口;
2:编写线程类(MyWorker),用于执行任务,需要持有所有任务;
3:编写线程池类(MyThreadPool),包含提交任务,执行任务的能力;
4:编写测试类(MyTest),创建线程池对象,提交多个任务测试;

MyTask

package com.itheima.demo01;
/*需求:自定义线程池练习,这是任务类,需要实现Runnable;包含任务编号,每一个任务执行时间设计为0.2秒*/
public class MyTask implements Runnable{private int id;//由于run方法是重写接口中的方法,因此id这个属性初始化可以利用构造方法完成public MyTask(int id) {this.id = id;}@Overridepublic void run() {String name = Thread.currentThread().getName();System.out.println("线程:"+name+" 即将执行任务:"+id);try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("线程:"+name+" 完成了任务:"+id);}@Overridepublic String toString() {return "MyTask{" +"id=" + id +'}';}
}

MyWorker

package com.itheima.demo01;import java.util.List;/*需求:编写一个线程类,需要继承Thread类,设计一个属性,用于保存线程的名字;设计一个集合,用于保存所有的任务;*/
public class MyWorker extends Thread{private String name;//保存线程的名字private List<Runnable> tasks;//利用构造方法,给成员变量赋值public MyWorker(String name, List<Runnable> tasks) {super(name);this.tasks = tasks;}@Overridepublic void run() {//判断集合中是否有任务,只要有,就一直执行任务while (tasks.size()>0){Runnable r = tasks.remove(0);r.run();}}
}

MyThreadPool

package com.itheima.demo01;import java.util.Collections;
import java.util.LinkedList;
import java.util.List;/*这是自定义的线程池类;成员变量:1:任务队列   集合  需要控制线程安全问题2:当前线程数量3:核心线程数量4:最大线程数量5:任务队列的长度成员方法1:提交任务;将任务添加到集合中,需要判断是否超出了任务总长度2:执行任务;判断当前线程的数量,决定创建核心线程还是非核心线程*/
public class MyThreadPool {// 1:任务队列   集合  需要控制线程安全问题private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());//2:当前线程数量private int num;//3:核心线程数量private int corePoolSize;//4:最大线程数量private int maxSize;//5:任务队列的长度private int workSize;public MyThreadPool(int corePoolSize, int maxSize, int workSize) {this.corePoolSize = corePoolSize;this.maxSize = maxSize;this.workSize = workSize;}//1:提交任务;public void submit(Runnable r){//判断当前集合中任务的数量,是否超出了最大任务数量if(tasks.size()>=workSize){System.out.println("任务:"+r+"被丢弃了...");}else {tasks.add(r);//执行任务execTask(r);}}//2:执行任务;private void execTask(Runnable r) {//判断当前线程池中的线程总数量,是否超出了核心数,if(num < corePoolSize){new MyWorker("核心线程:"+num,tasks).start();num++;}else if(num < maxSize){new MyWorker("非核心线程:"+num,tasks).start();num++;}else {System.out.println("任务:"+r+" 被缓存了...");}}}

MyTest

package com.itheima.demo01;
/*测试类:1: 创建线程池类对象;2: 提交多个任务*/
public class MyTest {public static void main(String[] args) {//1:创建线程池类对象;MyThreadPool pool = new MyThreadPool(2,4,20);//2: 提交多个任务for (int i = 0; i <30 ; i++) {//3:创建任务对象,并提交给线程池MyTask my = new MyTask(i);pool.submit(my);}}
}

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。

Java内置线程池-ExecutorService获取

获取ExecutorService可以利用JDK中的Executors 类中的静态方法,常用获取方式如下:
static ExecutorService newCachedThreadPool() 创建一个默认的线程池对象,里面的线程可重用,且在第一次使用时才创建 
static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) 线程池中的所有线程都使用ThreadFactory来创建,这样的线程无需手动启动,自动执行; 
static ExecutorService newFixedThreadPool(int nThreads)   创建一个可重用固定线程数的线程池 
static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) 创建一个可重用固定线程数的线程池且线程池中的所有线程都使用ThreadFactory来创建。 
static ExecutorService newSingleThreadExecutor() 创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。 
static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) 创建一个使用单个 worker 线程的 Executor，且线程池中的所有线程都使用ThreadFactory来创建。

newCachedThreadPool

package com.test;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;/*练习Executors获取ExecutorService,然后调用方法,提交任务;*/
public class MyTest01 {public static void main(String[] args) {
//        test1();test2();}//练习newCachedThreadPool方法private static void test1() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newCachedThreadPool();//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable(i));}}private static void test2() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newCachedThreadPool(new ThreadFactory() {int n=1;@Overridepublic Thread newThread(Runnable r) {return new Thread(r,"自定义的线程名称"+n++);}});//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable(i));}}
}
/*任务类,包含一个任务编号,在任务中,打印出是哪一个线程正在执行任务*/
class MyRunnable implements Runnable{private  int id;public MyRunnable(int id) {this.id = id;}@Overridepublic void run() {//获取线程的名称,打印一句话String name = Thread.currentThread().getName();System.out.println(name+"执行了任务..."+id);}
}

在这里插入图片描述

newFixedThreadPool

package com.test;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;/*练习Executors获取ExecutorService,然后调用方法,提交任务;*/
public class MyTest02 {public static void main(String[] args) {//test1();test2();}//练习方法newFixedThreadPoolprivate static void test1() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newFixedThreadPool(3);//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable2(i));}}private static void test2() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newFixedThreadPool(3,new ThreadFactory() {int n=1;@Overridepublic Thread newThread(Runnable r) {return new Thread(r,"自定义的线程名称"+n++);}});//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable2(i));}}
}/*任务类,包含一个任务编号,在任务中,打印出是哪一个线程正在执行任务*/
class MyRunnable2 implements Runnable{private  int id;public MyRunnable2(int id) {this.id = id;}@Overridepublic void run() {//获取线程的名称,打印一句话String name = Thread.currentThread().getName();System.out.println(name+"执行了任务..."+id);}
}

在这里插入图片描述

newSingleThreadExecutor

package com.test;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;/*练习Executors获取ExecutorService,然后调用方法,提交任务;*/
public class MyTest03 {public static void main(String[] args) {//test1();test2();}//练习方法newFixedThreadPoolprivate static void test1() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newSingleThreadExecutor();//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable3(i));}}private static void test2() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newSingleThreadExecutor(new ThreadFactory() {int n=1;@Overridepublic Thread newThread(Runnable r) {return new Thread(r,"自定义的线程名称"+n++);}});//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable3(i));}}
}/*任务类,包含一个任务编号,在任务中,打印出是哪一个线程正在执行任务*/
class MyRunnable3 implements Runnable{private  int id;public MyRunnable3(int id) {this.id = id;}@Overridepublic void run() {//获取线程的名称,打印一句话String name = Thread.currentThread().getName();System.out.println(name+"执行了任务..."+id);}
}

在这里插入图片描述

练习Executors获取ExecutorService,测试关闭线程池的方法;

package com.test;import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;/*练习Executors获取ExecutorService,测试关闭线程池的方法;*/
public class MyTest04 {public static void main(String[] args) {test1();
//        test2();}//练习方法newFixedThreadPoolprivate static void test1() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newSingleThreadExecutor();//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable4(i));}//3:关闭线程池,仅仅是不再接受新的任务,以前的任务还会继续执行es.shutdown();//es.submit(new MyRunnable4(888));//不能再提交新的任务了}private static void test2() {//1:使用工厂类获取线程池对象ExecutorService es = Executors.newSingleThreadExecutor(new ThreadFactory() {int n=1;@Overridepublic Thread newThread(Runnable r) {return new Thread(r,"自定义的线程名称"+n++);}});//2:提交任务;for (int i = 1; i <=10 ; i++) {es.submit(new MyRunnable4(i));}//3:立刻关闭线程池,如果线程池中还有缓存的任务,没有执行,则取消执行,并返回这些任务List<Runnable> list = es.shutdownNow();System.out.println(list);}
}/*任务类,包含一个任务编号,在任务中,打印出是哪一个线程正在执行任务*/
class MyRunnable4 implements Runnable{private  int id;public MyRunnable4(int id) {this.id = id;}@Overridepublic void run() {//获取线程的名称,打印一句话String name = Thread.currentThread().getName();System.out.println(name+"执行了任务..."+id);}@Overridepublic String toString() {return "MyRunnable4{" +"id=" + id +'}';}
}

Java内置线程池-ScheduledExecutorService

ScheduledExecutorService是ExecutorService的子接口,具备了延迟运行或定期执行任务的能力,


常用获取方式如下:
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个可重用固定线程数的线程池且允许延迟运行或定期执行任务;
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)创建一个可重用固定线程数的线程池且线程池中的所有线程都使用ThreadFactory来创建,且允许延迟运行或定期执行任务; 
static ScheduledExecutorService newSingleThreadScheduledExecutor() 创建一个单线程执行程序，它允许在给定延迟后运行命令或者定期地执行。 
static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。

ScheduledExecutorService常用方法如下:

<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) 延迟时间单位是unit,数量是delay的时间后执行callable。 ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) 延迟时间单位是unit,数量是delay的时间后执行command。  ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 延迟时间单位是unit,数量是initialDelay的时间后,每间隔period时间重复执行一次command。 ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

newScheduledThreadPool的schedule

package com.test.demo3;import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*测试ScheduleExecutorService接口中延迟执行任务和重复执行任务的功能*/
public class ScheduleExecutorServiceDemo01 {public static void main(String[] args) {//1:获取一个具备延迟执行任务的线程池对象ScheduledExecutorService es = Executors.newScheduledThreadPool(3);//2:创建多个任务对象,提交任务,每个任务延迟2秒执行for (int i=1;i<=10;i++){es.schedule(new MyRunnable(i),2, TimeUnit.SECONDS);}System.out.println("over");}
}
class MyRunnable implements Runnable{private int id;public MyRunnable(int id) {this.id = id;}@Overridepublic void run() {String name = Thread.currentThread().getName();System.out.println(name+"执行了任务:"+id);}
}

在这里插入图片描述

scheduleAtFixedRate方法

package com.test.demo3;import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;/*测试ScheduleExecutorService接口中延迟执行任务和重复执行任务的功能*/
public class ScheduleExecutorServiceDemo02 {public static void main(String[] args) {//1:获取一个具备延迟执行任务的线程池对象ScheduledExecutorService es = Executors.newScheduledThreadPool(3, new ThreadFactory() {int n = 1;@Overridepublic Thread newThread(Runnable r) {return new Thread(r,"自定义线程名:"+n++);}});//2:创建多个任务对象,提交任务,每个任务延迟2秒执行es.scheduleAtFixedRate(new MyRunnable2(1),1,2,TimeUnit.SECONDS);System.out.println("over");}
}class MyRunnable2 implements Runnable{private int id;public MyRunnable2(int id) {this.id = id;}@Overridepublic void run() {String name = Thread.currentThread().getName();try {Thread.sleep(1500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(name+"执行了任务:"+id);}
}

Java内置线程池-异步计算结果(Future)

我们刚刚在学习java内置线程池使用时,没有考虑线程计算的结果,但开发中,我们有时需要利用线程进行一些计算,然后获取这些计算的结果,而java中的Future接口就是专门用于描述异步计算结果的,我们可以通过Future 对象获取线程计算的结果;
Future 的常用方法如下:
boolean cancel(boolean mayInterruptIfRunning) 试图取消对此任务的执行。 V get() 如有必要，等待计算完成，然后获取其结果。 V get(long timeout, TimeUnit unit) 如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。 boolean isCancelled() 如果在任务正常完成前将其取消，则返回 true。 boolean isDone() 如果任务已完成，则返回 true。 

package com.itheima.demo04;import java.util.concurrent.*;/*练习异步计算结果*/
public class FutureDemo {public static void main(String[] args) throws Exception {//1:获取线程池对象ExecutorService es = Executors.newCachedThreadPool();//2:创建Callable类型的任务对象Future<Integer> f = es.submit(new MyCall(1, 1));//3:判断任务是否已经完成//test1(f);boolean b = f.cancel(true);//System.out.println("取消任务执行的结果:"+b);//Integer v = f.get(1, TimeUnit.SECONDS);//由于等待时间过短,任务来不及执行完成,会报异常//System.out.println("任务执行的结果是:"+v);}//正常测试流程private static void test1(Future<Integer> f) throws InterruptedException, ExecutionException {boolean done = f.isDone();System.out.println("第一次判断任务是否完成:"+done);boolean cancelled = f.isCancelled();System.out.println("第一次判断任务是否取消:"+cancelled);Integer v = f.get();//一直等待任务的执行,直到完成为止System.out.println("任务执行的结果是:"+v);boolean done2 = f.isDone();System.out.println("第二次判断任务是否完成:"+done2);boolean cancelled2 = f.isCancelled();System.out.println("第二次判断任务是否取消:"+cancelled2);}
}
class MyCall implements Callable<Integer>{private int a;private int b;//通过构造方法传递两个参数public MyCall(int a, int b) {this.a = a;this.b = b;}@Overridepublic Integer call() throws Exception {String name = Thread.currentThread().getName();System.out.println(name+"准备开始计算...");Thread.sleep(2000);System.out.println(name+"计算完成...");return a+b;}
}

综合案例-秒杀商品

案例介绍:假如某网上商城推出活动,新上架10部新手机免费送客户体验,要求所有参与活动的人员在规定的时间同时参与秒杀挣抢,假如有20人同时参与了该活动,请使用线程池模拟这个场景,保证前10人秒杀成功,后10人秒杀失败;
要求:1:使用线程池创建线程2:解决线程安全问题
思路提示:1:既然商品总数量是10个,那么我们可以在创建线程池的时候初始化线程数是10个及以下,设计线程池最大数量为10个;2:当某个线程执行完任务之后,可以让其他秒杀的人继续使用该线程参与秒杀;3:使用synchronized控制线程安全,防止出现错误数据;
代码步骤:1:编写任务类,主要是送出手机给秒杀成功的客户;2:编写主程序类,创建20个任务(模拟20个客户);3:创建线程池对象并接收20个任务,开始执行任务;

package com.itheima.demo05;
/*任务类:包含了商品数量,客户名称,送手机的行为;*/
public class MyTask implements Runnable {//设计一个变量,用于表示商品的数量private static int id = 10;//表示客户名称的变量private String userName;public MyTask(String userName) {this.userName = userName;}@Overridepublic void run() {String name = Thread.currentThread().getName();System.out.println(userName+"正在使用"+name+"参与秒杀任务...");try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}synchronized (MyTask.class){if(id>0){System.out.println(userName+"使用"+name+"秒杀:"+id-- +"号商品成功啦!");}else {System.out.println(userName+"使用"+name+"秒杀失败啦!");}}}
}
package com.itheima.demo05;import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*主程序类,测试任务类*/
public class MyTest {public static void main(String[] args) {//1:创建一个线程池对象ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,1, TimeUnit.MINUTES,new LinkedBlockingQueue<>(15));//2:循环创建任务对象for (int i = 1; i <=20 ; i++) {MyTask myTask = new MyTask("客户"+i);pool.submit(myTask);}//3:关闭线程池pool.shutdown();}
}
案例介绍:设计一个程序,使用两个线程模拟在两个地点同时从一个账号中取钱,假如卡中一共有1000元,每个线程取800元,要求演示结果一个线程取款成功,剩余200元,另一个线程取款失败,余额不足;
要求:1:使用线程池创建线程2:解决线程安全问题

思路提示:1:线程池可以利用Executors工厂类的静态方法,创建线程池对象;2:解决线程安全问题可以使用synchronized方法控制取钱的操作3:在取款前,先判断余额是否足够,且保证余额判断和取钱行为的原子性;

package com.itheima.demo06;public class MyTask implements Runnable {//用户姓名private String userName;//取款金额private double money;//总金额private static double total = 1000;public MyTask(String userName, double money) {this.userName = userName;this.money = money;}@Overridepublic void run() {String name = Thread.currentThread().getName();System.out.println(userName+"正在准备使用"+name+"取款:"+money+"元");try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}synchronized (MyTask.class){if(total-money>0){System.out.println(userName+"使用"+name+"取款:"+money+"元成功,余额:"+(total-money));total-=money;}else {System.out.println(userName+"使用"+name+"取款:"+money+"元失败,余额:"+total);}}}
}
package com.itheima.demo06;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;public class MyTest {public static void main(String[] args) {//1:创建线程池对象ExecutorService pool = Executors.newFixedThreadPool(2, new ThreadFactory() {int id = 1;@Overridepublic Thread newThread(Runnable r) {return new Thread(r, "ATM" + id++);}});//2:创建两个任务并提交for (int i = 1; i <=2 ; i++) {MyTask myTask = new MyTask("客户" + i, 800);pool.submit(myTask);}//3:关闭线程池pool.shutdown();}
}

线程池总结

线程池的使用步骤可以归纳总结为五步 :

1:利用Executors工厂类的静态方法,创建线程池对象;
2:编写Runnable或Callable实现类的实例对象;
3:利用ExecutorService的submit方法或ScheduledExecutorService的schedule方	法提交并执行线程任务
4:如果有执行结果,则处理异步执行结果(Future)
5:调用shutdown()方法,关闭线程池

java基础面试（最新版）参考

序列号内容链接
1Java基础知识面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124023797
2Java集合容器面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124043363
3Java异常面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124078378
4并发编程面试题 （2022版）https://blog.csdn.net/qq_43061290/article/details/124104563
5JVM面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124104514
6Spring面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124227864
7Spring MVC面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124337927
8Spring Boot面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124339493
9Spring Cloud面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124341152
10MyBatis面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124468306
11Redis面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124427311
12MySQL数据库面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124427311
13消息中间件MQ知识点（2022版）https://blog.csdn.net/qq_43061290/article/details/124542376
14ZooKeeper面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124548428
15架构设计&分布式&数据结构与算法面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124624540
16计算机网络编程面试题（2022版）https://blog.csdn.net/qq_43061290/article/details/124041420

MySQL优化（通俗易懂）

序列号内容链接
1Mysql深入优化 (一) ----- 索引、视图、存储过程、触发器https://blog.csdn.net/qq_43061290/article/details/125410648
2Mysql深入优化 (二) ----- 体系结构、存储引擎、SQL优化https://blog.csdn.net/qq_43061290/article/details/125410728
3Mysql深入优化 (三) ----- 查询缓存、内存管理及优化、MySQL锁问题https://blog.csdn.net/qq_43061290/article/details/125410781
4Mysql深入优化 (四) ----- MySQL常用工具、日志、主从复制、综合案例https://blog.csdn.net/qq_43061290/article/details/125410813

大数据面试知识点（参考）

序列号内容链接
1大数据知识面试题-通用（2022版）https://blog.csdn.net/qq_43061290/article/details/124819089
2大数据知识面试题-Hadoop（2022版）https://blog.csdn.net/qq_43061290/article/details/124822293
3大数据知识面试题-MapReduce和yarn（2022版）https://blog.csdn.net/qq_43061290/article/details/124841929
4大数据知识面试题-Zookeepr （2022版）https://blog.csdn.net/qq_43061290/article/details/124548428
5大数据知识面试题-Hive （2022版）https://blog.csdn.net/qq_43061290/article/details/125105485
6大数据知识面试题-Flume（2022版）https://blog.csdn.net/qq_43061290/article/details/125132610
7大数据知识面试题-Hbase（2022版）https://blog.csdn.net/qq_43061290/article/details/125145399
8大数据知识面试题-sqoop（2022版）https://blog.csdn.net/qq_43061290/article/details/125145736
9大数据知识面试题-Kafka（2022版）https://blog.csdn.net/qq_43061290/article/details/125145841
10大数据知识面试题-Azkaban（2022版）https://blog.csdn.net/qq_43061290/article/details/125146859
11大数据知识面试题-Scala （2022版）https://blog.csdn.net/qq_43061290/article/details/125145976
12大数据知识面试题-Spark （2022版）https://blog.csdn.net/qq_43061290/article/details/125146030
13大数据知识面试题-Flink（2022版）https://blog.csdn.net/qq_43061290/article/details/125182137

前端面试知识点（参考）

序列号内容链接
1前端知识面试题 - http&https（2022版）https://blog.csdn.net/qq_43061290/article/details/126651783
2前端知识面试题 - 浏览器（2022版）https://blog.csdn.net/qq_43061290/article/details/126776538
3前端知识面试题 - HTML && CSS（2022版）https://blog.csdn.net/qq_43061290/article/details/126776849
4.1前端知识面试题 - JavaScript（2022版）https://blog.csdn.net/qq_43061290/article/details/126845296
4.2前端知识面试题 - JavaScript（2022版）https://blog.csdn.net/qq_43061290/article/details/126863862
5前端知识面试题 - TypeScript （2022版）https://blog.csdn.net/qq_43061290/article/details/126985012
6.1前端知识面试题 - Vue&&VueJs（2022版）https://blog.csdn.net/qq_43061290/article/details/127021227
6.2前端知识面试题 - Vue&&VueJs（2022版）https://blog.csdn.net/qq_43061290/article/details/127021289
7前端知识面试题 - React（2022版）https://blog.csdn.net/qq_43061290/article/details/126690239
8前端知识面试题 - nodeJs（2022版）https://blog.csdn.net/qq_43061290/article/details/127140848
9前端知识面试题 - Augluar（2022版）https://blog.csdn.net/qq_43061290/article/details/127191959

http://chatgpt.dhexx.cn/article/IATGZpfl.shtml

相关文章

Java 多线程：彻底搞懂线程池

Java 多线程：彻底搞懂线程池

熟悉 Java 多线程编程的同学都知道&#xff0c;当我们线程创建过多时&#xff0c;容易引发内存溢出&#xff0c;因此我们就有必要使用线程池的技术了。 目录 1 线程池的优势 2 线程池的使用 3 线程池的工作原理 4 线程池的参数 4.1 任务队列&#xff08;workQueue&#x…
阅读更多...
GridView概述

GridView概述

一、使用GridView以表格形式显示多张图片 GridView用于在界面上按行、列分布的方式来显示多个组件 二、使用GridView 1、java代码 import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import android.widget.AdapterV…
阅读更多...
Master-Detail GridView

Master-Detail GridView

梦幻版Master-Detail GridView(黄忠成) 2007-12-26 09:34 前面的Master-Detail GridView控件應用&#xff0c;相信你已在市面上的書、或網路上見過&#xff0c;但此節中的GridView控件應用包你沒看過&#xff0c;但一定想過&#xff01;請見圖4-8-63。 圖4-8-63 圖 4-8-64 你一…
阅读更多...
GridView DataGrid

GridView DataGrid

ASP.NET 2.0提供了功能强大的数据绑定控件GridView、在使用中&#xff0c;一些属性和方法经常会与ASP.NET 1.1中的DataGrid混淆(VS2005中依然可以使用DataGrid&#xff0c;手动添加到工具箱或HTML状态输入代码)&#xff0c;下面我们分别用GridView和DataGrid实现其数据绑定、编…
阅读更多...
GridView详讲

GridView详讲

GridView是ASP.NET界面开发中的一个重要的控件&#xff0c;对GridView使用的熟练程度直接影响软件开发的进度及功能的实现。(车延禄) GridView的主要新特性&#xff1a; 1.与DataSource控件结合实现了显示与数据操作的分离&#xff0c;大大减化了代码的编写量; 2.实现"双向…
阅读更多...
GridView详述

GridView详述

GridView无代码分页排序GridView选中&#xff0c;编辑&#xff0c;取消&#xff0c;删除GridView正反双向排序GridView和下拉菜单DropDownList结合GridView和CheckBox结合鼠标移到GridView某一行时改变该行的背景色方法一鼠标移到GridView某一行时改变该行的背景色方法二GridVi…
阅读更多...
GridView、ListView、Adapter、Map、HashMap

GridView、ListView、Adapter、Map、HashMap

1.ListView自定义适配器adapter 注&#xff1a;Android适配器是数据和视图之间的桥梁&#xff0c;以便于数据在View上显示。适配器就像显示器&#xff0c;把复杂的东西按人可以接受的方式来展现。 &#xff08;1&#xff09;首先将适配器的View视图表现出来&#xff0c;使用L…
阅读更多...
GridViewPager

GridViewPager

GridViewPager ViewPager结合GridView&#xff0c;轻松实现类似表情面板的控件。可自由定制Item布局&#xff0c;提供充足的自定义参数等。也处理了条目点击事件和条目长按事件。效果如下&#xff1a; Demo下载地址&#xff1a;GridViewPager &#xff0c;或者扫描以下二维码…
阅读更多...
libevent 编译

libevent 编译

1.下载源码 github:https://github.com/libevent/libevent 官网&#xff1a;http://libevent.org/ 2.CMake 编译 在libevent源码目录建立文件夹&#xff1a;BuildVs2010_x64 2.打开CMake 3.BuildVs2010_x64 下此时生成了vs2010的解决方案。然后编译生成就ok NOTE&#x…
阅读更多...
13、《Libevent中文帮助文档》学习笔记13：Linux下集成、运行libevent

13、《Libevent中文帮助文档》学习笔记13：Linux下集成、运行libevent

Linux下编译libevent的指导可以参考《4、《Libevent中文帮助文档》学习笔记4&#xff1a;Linux下编译libevent》&#xff0c;完成编译、安装&#xff0c;生成so库后&#xff0c;其他程序即可依赖libevent的so库&#xff0c;使用libevent的功能。 由于没有通过prefix指定安装路…
阅读更多...
libevent 编译与安装 (WIN10 visual studio2019, ubuntu，centos)

libevent 编译与安装 (WIN10 visual studio2019, ubuntu，centos)

文章目录 一、准备安装包二、编译与安装编译zlib编译openssl编译libevent 三、libevent集成zlib测试程序修改编译&#xff08;可选&#xff09;四、测试程序五、linux(ubuntu)测试安装依赖环境&#xff0c;依次编译zlib,openssl,libeventwindows与linux共享文件夹&#xff08;使…
阅读更多...
Libevent 学习一：Libevent 源码编译

Libevent 学习一：Libevent 源码编译

文章目录 Libevent 学习一&#xff1a;Libevent 源码编译Libevent Windows 编译Windows 编译环境安装 Visual Studio Community 2015安装 zlib安装 OpenSSL安装 Libeventcmake 安装 LibeventLibevent 测试程序 Libevent Linux编译CentOS 7 安装 LibeventLibevent 测试程序 Libe…
阅读更多...
libevent mysql_libevent安装总结

libevent mysql_libevent安装总结

1.先用&#xff1a;ls -al /usr/lib | grep libevent 查看是否已安装&#xff1b;如果已安装且版本低于1.3&#xff0c;则先通过&#xff1a;rpm -e libevent —nodeps进行卸载。 2.下载libevent安装包&#xff1a;libevent-2.0.18-stable.tar.gz。 wget https://github.com/do…
阅读更多...
在window用vcpkg安装libevent

在window用vcpkg安装libevent

参考readme https://github.com/microsoft/vcpkg/blob/master/README_zh_CN.md 使用的PackageManager方式安装&#xff0c; Package Managers 下载 vcpkg 依赖管理包 git clone https://github.com/Microsoft/vcpkg.git cd vcpkg ./bootstrap-vcpkg.bat ./vcpkg integrate…
阅读更多...
libevent实践01：准备源码、搭建项目、编译脚本和入门例子

libevent实践01：准备源码、搭建项目、编译脚本和入门例子

编译源码 libevent是一个Reactor事件库。 我的理解&#xff0c;就是封装了select、epoll、poll的函数库。有使用select&#xff0c;poll&#xff0c;epoll的需求就可以使用的。 官网地址&#xff1a;https://libevent.org/ 下载源码&#xff1a; https://github.com/libev…
阅读更多...
libevent（1）windows下安装libevent

libevent（1）windows下安装libevent

Socket通信库libevent成熟、稳定、性能高&#xff0c;在unix和windows下都能使用&#xff0c;在证券交易领域也有不少成功的应用&#xff0c;已经用事实证明是非常棒的socket通信库。对我们目前交易系统的unix重构来说&#xff0c;是比较合适的选择 –– 坑少、在证券交易项目中…
阅读更多...
Libevent库的学习

Libevent库的学习

目录 Libevent 概述 Libevent 使用模型 使用Libevent的基本流程&#xff1a; libevent 的核心&#xff0c;event 事件 1. 创建一个事件event 2. 释放event_free 3. 注册event 4. 信号事件 5. 销毁event_base Libevent 结构图 使用libevent库去实现tcp服务器 Libev…
阅读更多...
编译libevent

编译libevent

本文记录在win10编译libevent的过程 1.编译前准备zlib,openssl zlib网址 http://www.zlib.net/ 下载源码解压缩 打开vs的dos窗口 32位选择32位窗口这里选择64位,cd 到解压后的文件夹 执行 nmake /f win32/Makefile.msc 执行后可以看到目录下有lib文件和dll文件和测试文件…
阅读更多...
libevent简要介绍

libevent简要介绍

libevent库 开源。精简。跨平台&#xff08;Windows、Linux、Maxos、unix&#xff09;。专注于网络通信。 源码包安装&#xff1a; ./configure 检查安装环境 生成makefile make 生成.o和可执行文件 sudo make install …
阅读更多...
Libevent库的简介

Libevent库的简介

一、libevent是什么 Libevent 是一个用C语言编写的、轻量级的开源高性能事件通知库&#xff0c;主要有以下几个亮点&#xff1a;事件驱动&#xff08; event-driven&#xff09;&#xff0c;高性能;轻量级&#xff0c;专注于网络&#xff0c;不如 ACE 那么臃肿庞大&#xff1b…
阅读更多...
推荐文章

Copyright @ 2022~2023