为什么使用线程池

合集下载

线程池的原理

线程池的原理

线程池的原理
线程池是一种并发处理机制,在程序启动时创建一定数量的线程,并且维护一个任务队列。

当有任务需要处理时,线程池中的线程会从任务队列中取出任务进行处理。

线程池的原理如下:
1. 创建线程池:在程序初始化时,创建一定数量的线程,并且将它们置于等待状态,等待任务的到来。

2. 添加任务:当有任务需要处理时,将任务添加到任务队列中。

3. 任务分配:线程池中的线程会不断地从任务队列中取出任务进行处理,直到任务队列为空。

每个线程只能处理一个任务,处理完后会再次进入等待状态。

4. 线程复用:当一个线程处理完一个任务后,可以立即处理下一个任务,而不需要销毁和重新创建线程,从而减少了线程创建和销毁的开销。

5. 线程管理:线程池管理线程的数量,根据实际需要动态调整线程的数量。

可以根据线程池的策略,动态增加或减少线程的数量。

6. 控制并发:线程池可以控制并发的数量,防止因为任务过多导致系统内存溢出或者性能下降。

7. 错误处理:线程池中的线程处理任务时可能会产生异常,需要对异常进行处理,防止线程因为异常退出而导致整个线程池无法正常工作。

通过使用线程池,我们可以更好地管理线程,提高程序的性能和可靠性。

Java线程池使用和常用参数

Java线程池使用和常用参数

Java线程池使⽤和常⽤参数多线程问题:1、java中为什么要使⽤多线程使⽤多线程,可以把⼀些⼤任务分解成多个⼩任务来执⾏,多个⼩任务之间互不影像,同时进⾏,这样,充分利⽤了cpu资源。

2、java中简单的实现多线程的⽅式继承Thread类,重写run⽅法;12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28class MyTread extends Thread{public void run() { System.out.println(Thread.currentThread().getName());}}实现Runable接⼝,实现run⽅法;class MyRunnable implements Runnable{ public void run() { System.out.println(Thread.currentThread().getName()); }}class ThreadTest { public static void main(String[] args) { MyTread thread = new Mythread(); thread.start(); //开启⼀个线程 MyRunnable myRunnable = new MyRunnable(); Thread runnable = new Thread(myRunnable); runnable.start(); //开启⼀个线程 }}3、java线程的状态创建:当new了⼀个线程,并没有调⽤start之前,线程处于创建状态;就绪:当调⽤了start之后,线程处于就绪状态,这是,线程调度程序还没有设置执⾏当前线程;运⾏:线程调度程序执⾏到线程时,当前线程从就绪状态转成运⾏状态,开始执⾏run⽅法⾥边的代码;阻塞:线程在运⾏的时候,被暂停执⾏(通常等待某项资源就绪后在执⾏,sleep、wait可以导致线程阻塞),这是该线程处于阻塞状态;死亡:当⼀个线程执⾏完run⽅法⾥边的代码或调⽤了stop⽅法后,该线程结束运⾏4、为什么要引⼊线程池当我们需要的并发执⾏线程数量很多时,且每个线程执⾏很短的时间就结束了,这样,我们频繁的创建、销毁线程就⼤⼤降低了⼯作效率(创建和销毁线程需要时间、资源)。

线程池参数设置原则

线程池参数设置原则

线程池参数设置原则为什么要使⽤线程池? 为了减少创建和销毁线程的次数,让每个线程都可以多次的使⽤,可以根据系统情况调整线程的数量,防⽌消耗过多内存。

在实际使⽤中,服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当⼤,使⽤线程池就可以优化。

在java中,如果每个请求到达就创建⼀个新线程,开销是相当⼤的。

在实际使⽤中,服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当⼤,甚⾄可能要⽐在处理实际的⽤户请求的时间和资源要多的多。

除了创建和销毁线程的开销之外,活动的线程也需要消耗系统资源。

如果在⼀个jvm⾥创建太多的线程,可能会使系统由于过度消耗内存或“切换过度”⽽导致系统资源不⾜。

为了防⽌资源不⾜,服务器应⽤程序需要采取⼀些办法来限制任何给定时刻处理的请求数⽬,尽可能减少创建和销毁线程的次数,特别是⼀些资源耗费⽐较⼤的线程的创建和销毁,尽量利⽤已有对象来进⾏服务,这就是“池化资源”技术产⽣的原因。

线程池主要⽤来解决线程⽣命周期开销问题和资源不⾜问题。

通过对多个任务重复使⽤线程,线程创建的开销就被分摊到了多个任务上了,⽽且由于在请求到达时线程已经存在,所以消除了线程创建所带来的延迟。

这样,就可以⽴即为请求服务,使⽤应⽤程序响应更快。

另外,通过适当的调整线程中的线程数⽬可以防⽌出现资源不⾜的情况。

⼀:线程池参数简介ThreadPoolExecutor类可设置的参数主要有:corePoolSize:核⼼线程1.核⼼线程会⼀直存活,及时没有任务需要执⾏2.当线程数⼩于核⼼线程数时,即使有线程空闲,线程池也会优先创建新线程处理3.设置allowCoreThreadTimeout=true(默认false)时,核⼼线程会超时关闭queueCapacity:任务队列容量(阻塞队列)当核⼼线程数达到最⼤时,新任务会放在队列中排队等待执⾏maxPoolSize:最⼤线程数1.当线程数>=corePoolSize,且任务队列已满时。

c++ 线程池的工作原理

c++ 线程池的工作原理

c++ 线程池的工作原理
线程池是一种用于管理和控制执行多个线程的机制。

它包括一个工作队列,该队列用于保存任务的列表,并且有一组已经准备就绪的线程可以执行这些任务。

线程池的工作原理如下:
1. 创建线程池:首先要创建线程池,这个过程中需要指定线程池的大小,最大任务队列长度以及线程池的优先级等参数。

2. 将任务添加到任务队列:当一个任务需要执行时,它会被添加到任务队列中等待执行。

3. 分配任务给线程:线程池中的线程会从任务队列中取出任务并执行。

当一个线程处于空闲状态时,它会从任务队列中获取一个任务并执行。

4. 执行任务:线程会执行任务,当任务完成时,线程会从任务队列中获取另一个任务并执行,直到所有任务都被执行完或线程池被关闭。

5. 关闭线程池:当线程池不再需要时,它会接收到关闭信号,并关闭线程池中所有线程,释放资源。

总之,线程池通过对任务队列的管理来有效地控制线程数量和执行顺序,从而提高了应用程序的性能和可靠性。

进程和线程面试题

进程和线程面试题

进程和线程⾯试题1、线程和进程线程:线程是进程的⼀个实体,是CPU调度和分派的基本单元。

进程:进程是具有⼀定独⽴功能的程序,它是系统进程资源分配和调度的⼀个独⽴单元。

区别:(1)⼀个线程只属于⼀个进程,⼀个进程包含⼀个或者多个线程。

(2)进程拥有独⽴的内存单元,⽽多个线程共享内存。

(3)进程的创建调⽤fork或者vfork,⽽线程的创建调⽤pthead_create,进程结束后它拥有的所有线程都将销毁,⽽线程的结束不会影响同个进程中的其他线程的结束。

(4)线程是轻量级的进程,它的创建和销毁所需要的时间⽐进程⼩很多,所有操作系统中的执⾏功能都是创建线程去完成的。

(5)线程中执⾏时⼀般都要进⾏同步和互斥,因为他们共享同⼀进程的资源。

2、死锁?死锁产⽣的原因?死锁的必要条件?怎么处理死锁?死锁:死锁是指两个或者两个以上的进程在执⾏过程中,由于竞争资源或者由于彼此通信⽽造成的⼀种阻塞的现象。

死锁原因:系统资源不⾜、相互竞争资源。

请求资源顺序不当死锁的必要条件:1.互斥条件:⼀个资源每次只能被⼀个进程使⽤。

2.请求和保持条件:⼀个进程因请求资源⽽阻塞时,对已获得的资源保持不放。

3.不可剥夺条件:进程已获得的资源,在未使⽤完之前,不能强⾏剥夺,只能在进程使⽤完时由⾃⼰释放。

4.循环等待条件:若⼲进程之间形成⼀种头尾相接的循环等待资源关系。

避免死锁的⽅法:因为互斥是不可改变的,所以只能破坏其他三个条件中的⼀个来解除死锁,⽅法:剥夺资源、杀死其中⼀个线程。

避免死锁最简单的⽅法就是阻⽌循环等待条件,将系统中所有的资源设置标志位、排序,规定所有的进程申请资源必须以⼀定的顺序做操作来避免死锁。

3、如何在Java中实现线程?(1)继承Thread类(2)实现Runnable接⼝(3)实现Callable接⼝通过FutureTask包装器来创建Thread线程(4)使⽤ExecutorService、Callable、Future实现有返回结果的多线程4、⽤Runnable还是Thread?Java不⽀持类的多重继承,但允许你调⽤多个接⼝(当然是调⽤Runnable接⼝更好)5、Thread类中start()和run()⽅法有什么区别?(1)start()⽅法被⽤来启动新创建的线程,⽽start()内部调⽤了run()⽅法。

使用线程池的优点

使用线程池的优点

使用线程池的优点线程池是一种用于处理多线程任务的程序设计概念,它提供了一种管理和复用线程的机制。

线程池由线程池管理器和一组可复用的线程组成。

线程池的使用可以提供以下优点。

1.提高性能和响应速度:线程池可以有效地利用系统资源,通过重用线程,避免了频繁地创建和销毁线程的开销。

这样可以减少系统的负载,并且能够更快地响应新任务的到来。

2.控制并发线程数:线程池能够限制并发线程的数量,这样可以避免因过多线程任务而导致系统资源的枯竭。

通过线程池管理器的控制,可以动态调整线程的数量和使用情况,以满足应用程序的需求。

3.提高系统稳定性:线程池可以限制并控制同时执行的线程数量,避免系统因为过多的线程开销而崩溃。

通过管理线程的生命周期,线程池可以实现线程的统一管理、监控和复用,提高系统的稳定性和可靠性。

4.提供可管理的线程资源:线程池可以对线程的创建、销毁、调度和执行等行为进行统一管理,简化了线程的管理工作。

管理器可以根据系统负载和任务需求来动态调整线程池的大小,并监控线程的执行情况,提供可视化的线程状态和性能指标,方便开发人员进行线程的调优和故障排查。

5.支持任务队列和优先级调度:线程池通常支持任务队列,可以把多个任务放入队列中,由空闲线程来处理。

通过任务队列和优先级调度机制,可以灵活地管理和调度各类任务,提高任务的响应能力和执行效率。

6.利于代码复用和模块化设计:线程池可以封装复杂的线程管理逻辑,提供简洁、规范的接口,降低了线程编程的难度。

同时,线程池也方便代码的复用和模块化设计,可以把各个任务和线程处理逻辑进行分离,提高代码的可读性和可维护性。

7.提高系统的可伸缩性和扩展性:线程池支持动态调整线程数量和任务队列容量,可以根据应用程序的需求进行灵活的扩展和缩减。

这样可以有效地提高系统的可伸缩性,提升系统的处理能力和性能。

8.降低资源消耗和管理开销:线程池通过复用线程和控制线程的数量,减少了线程创建和销毁的开销,降低了系统资源的消耗。

如何在Java中进行并发计算和分布式系统的优化设计

如何在Java中进行并发计算和分布式系统的优化设计并发计算是指多个任务在同一时间段内同时执行的计算方式。

而分布式系统是指将一个计算机系统分布在不同的物理位置上,通过网络互联,形成一个整体的计算系统。

在Java中,可以使用多线程技术来实现并发计算,同时也可以使用分布式框架来优化分布式系统的设计。

1.并发计算的优化设计:在Java中,可以通过以下几种方式来优化并发计算的设计:1.1使用线程池:线程池是一个管理线程的工具,可以重用已创建的线程,有效地管理线程的创建和销毁。

通过使用线程池,可以避免频繁地创建和销毁线程所带来的开销,并且可以控制同时执行的线程数量,避免系统资源被过度占用。

1.2使用锁机制:Java提供了synchronized关键字和Lock接口来实现锁机制,可以保证多个线程访问共享资源的互斥性,避免数据竞争和不一致性。

在多线程环境下,通过合理的锁机制设计,可以提高并发计算的效率和准确性。

1.3使用并发容器:Java提供了一系列的并发容器,如ConcurrentHashMap、ConcurrentLinkedQueue等,这些容器在多线程环境下具有较高的并发性能。

通过使用并发容器,可以避免手动实现线程安全的数据结构,减少错误和并发问题的发生。

1.4使用无锁算法:无锁算法是一种高效的并发计算方式,通过使用原子操作或CAS(Compare and Swap)指令来实现多个线程对共享资源的并发操作,避免了锁机制带来的性能损耗。

在Java中,可以使用Atomic类或java.util.concurrent.atomic包下的原子类来实现无锁算法。

1.5使用并行流和并行算法:Java 8引入了Stream API和并行流(Parallel Stream),通过将计算任务分解为多个子任务,然后并行执行,可以利用多核处理器的性能优势,提高计算速度。

同时,还可以使用Java 8提供的并行算法,如并行排序、并行归约等,进一步提高并发计算的效率。

线程池的使用场景有哪些

线程池的使⽤场景有哪些线程池的各种使⽤场景1. 线程池的使⽤场景有哪些线程池适合单系统的⼤量的异步任务处理,⽐如发送短信、保存⽇志。

2. 说说创建线程池的重要参数corePoolSize:线程池的⼤⼩。

线程池创建之后不会⽴即去创建线程,⽽是等待线程的到来。

当前执⾏的线程数⼤于该值时,线程会加⼊到缓冲队列。

maximumPoolSize:线程池中创建的最⼤线程数。

keepAliveTime:空闲的线程多久时间后被销毁。

默认情况下,该值在线程数⼤于corePoolSize时,对超出corePoolSize值的这些线程起作⽤。

unit:TimeUnit枚举类型的值,代表keepAliveTime时间单位。

handler:线程拒绝策略。

3. 这些参数怎么设置,线程池调优怎么做基本思想:1. ⾼并发、任务执⾏时间短的业务,线程池线程数可以设置为CPU核数+1,减少线程上下⽂的切换。

2. 并发不⾼、任务执⾏时间长的业务要区分开:1. IO密集型的任务,因为IO操作并不占⽤CPU,可以加⼤线程池中的线程数⽬,让CPU处理更多的业务2. CPU密集型任务,线程池中的线程数设置得少⼀些,减少线程上下⽂的切换。

3. 并发⾼、业务执⾏时间长,在于整体架构的设计,能否使⽤中间件对任务进⾏拆分和解耦。

具体设置:1. corePoolSize = 每秒需要多少个线程处理threadcount = tasks/(1/taskcost) =tasks taskcout = (500~1000)0.1 = 50~100 个线程。

corePoolSize设置应该⼤于50。

根据8020原则,如果80%的每秒任务数⼩于800,那么corePoolSize设置为80即可。

2. queueCapacity = (coreSizePool/taskcost) * responsetime计算可得 queueCapacity = 80/0.1*1 = 80,意思是队列⾥的线程可以等待1s,超过了的需要新开线程来执⾏。

java线程池的工作原理

java线程池的工作原理
Java线程池的工作原理如下:
1. 线程池的初始化:在使用线程池之前,需要首先创建一个线程池对象,并设定线程池的核心线程数、最大线程数、线程空闲时间等参数。

2. 任务提交:当有任务需要执行时,可以使用线程池的
submit()或execute()方法将任务提交给线程池。

3. 任务队列:线程池会维护一个任务队列,用于存储提交的任务。

如果线程池中的线程数没有达到核心线程数,线程池就会创建新的线程来执行任务。

如果线程池中的线程数已经达到核心线程数,但任务队列仍然可以存储新任务,线程池会将新任务存储在任务队列中。

4. 线程池的工作方式:线程池会不断地从任务队列中取出任务,并通过线程池中的线程来执行任务。

若线程池中的线程处于空闲状态,则会被重新利用,否则任务会等待直到有线程可用。

5. 线程池的扩容:当任务队列已满且线程池中的线程数未达到最大线程数时,线程池会创建新的线程来执行任务。

一旦线程数达到最大线程数,线程池将不再接受新的任务。

6. 线程池的关闭:当不再需要线程池时,可以调用线程池的shutdown()方法来关闭线程池。

关闭线程池后,线程池将不再
接受新的任务,同时会等待已提交的任务执行完毕。

可以使用
awaitTermination()方法来等待所有任务执行完毕。

线程池的好处是提高了线程的利用率,避免了频繁创建和销毁线程的开销。

同时可以控制线程的并发数,防止系统资源过度消耗。

线程池在实际项目中的运用举例

线程池在实际项目中有很多应用场景,以下是一些常见的例子:
1. 服务器端编程:在服务器端应用中,线程池可以用于处理并发的客户端请求。

通过创建一个固定大小的线程池,服务器可以同时处理多个请求,提高系统的并发处理能力。

2. 图像或视频处理:在图像处理、视频编码等任务中,线程池可以用于并行处理图像的不同部分或视频的帧,加快处理速度。

3. 数据库操作:在数据库应用中,线程池可以用于并行执行数据库查询或数据处理任务,提高数据库的性能。

4. 网络通信:在网络编程中,线程池可以用于处理并发的网络连接或数据传输。

5. 任务调度:线程池可以用于任务调度系统中,将任务分配给可用的线程执行,提高任务处理的效率。

例如,在一个Web 服务器中,可以使用线程池来处理客户端的HTTP 请求。

当有新的请求到来时,线程池会分配一个线程来处理该请求,处理完成后线程返回线程池,等待下一个请求。

这样可以避免频繁地创建和销毁线程,提高服务器的性能和响应速度。

通过使用线程池,可以有效地管理和利用系统资源,提高程序的性能和并发处理能力。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

一、为什么用线程池1、创建/销毁线程伴随着系统开销,过于频繁的创建/销毁线程,会很大程度上影响处理效率>例如:>>记创建线程消耗时间T1,执行任务消耗时间T2,销毁线程消耗时间T3>>如果T1+T3>T2,那么是不是说开启一个线程来执行这个任务太不划算了!>>正好,线程池缓存线程,可用已有的闲置线程来执行新任务,避免了T1+T3带来的系统开销2、线程并发数量过多,抢占系统资源从而导致阻塞>我们知道线程能共享系统资源,如果同时执行的线程过多,就有可能导致系统资源不足而产生阻塞的情况>>运用线程池能有效的控制线程最大并发数,避免以上的问题3、对线程进行一些简单的管理>比如:延时执行、定时循环执行的策略等>>运用线程池都能进行很好的实现二、线程池ThreadPoolExecutor在Java 中,线程池的概念是Executor 这个接口,具体实现为ThreadPoolExecutor 类,学习Java 中的线程池,就可以直接学习他了对线程池的配置,就是对ThreadPoolExecutor 构造函数的参数的配置,既然这些参数这么重要,就来看看构造函数的各个参数吧ThreadPoolExecutor提供了四个构造函数//五个参数的构造函数public ThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable>workQueue)//六个参数的构造函数-1public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable>workQueue,ThreadFactory threadFactory)//六个参数的构造函数-2public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable>workQueue, RejectedExecutionHandlerhandler)//七个参数的构造函数public ThreadPoolExecutor(intcorePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable>workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)•我知道你看到这些构造函数和我一样也是吓呆了,但其实一共就7种类型,理解起来简直和理解一周有7天一样简单,而且一周有两天是周末,其实也就只有5天需要了解!• int corePoolSize=>该线程池中核心线程数最大值>核心线程:>>线程池新建线程的时候,如果当前线程总数小于corePoolSize,则新建的是核心线程,如果超过corePoolSize,则新建的是非核心线程>>核心线程默认情况下会一直存活在线程池中,即使这个核心线程啥也不干(闲置状态)。

>>如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true,那么核心线程如果不干活(闲置状态)的话,超过一定时间(时长下面参数决定),就会被销毁掉>• int maximumPoolSize>该线程池中线程总数最大值>>线程总数= 核心线程数+ 非核心线程数。

核心线程在上面解释过了,这里说下非核心线程:>• long keepAliveTime>该线程池中非核心线程闲置超时时长>>一个非核心线程,如果不干活(闲置状态)的时长超过这个参数所设定的时长,就会被销毁掉>>如果设置allowCoreThreadTimeOut = true,则会作用于核心线程• TimeUnit unit> keepAliveTime的单位,TimeUnit是一个枚举类型,其包括:>> 1. NANOSECONDS :1微毫秒= 1微秒/ 1000> 2. MICROSECONDS :1微秒= 1毫秒/ 1000> 3. MILLISECONDS :1毫秒= 1秒/1000>4. SECONDS :秒> 5. MINUTES :分> 6. HOURS :小时> 7. DAYS :天• BlockingQueue<Runnable> workQueue>该线程池中的任务队列:维护着等待执行的Runnable对象>>当所有的核心线程都在干活时,新添加的任务会被添加到这个队列中等待处理,如果队列满了,则新建非核心线程执行任务>>常用的workQueue类型:>> 1. SynchronousQueue:这个队列接收到任务的时候,会直接提交给线程处理,而不保留它如果所有线程都在工作怎么办?那就新建一个线程来处理这个任务!所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误,使用这个类型队列的时候,maximumPoolSize一般指定成Integer.MAX_VALUE,即无限大>> 2. LinkedBlockingQueue:这个队列接收到任务的时候,如果当前线程数小于核心线程数,则新建线程(核心线程)处理任务;如果当前线程数等于核心线程数,则进入队列等待。

由于这个队列没有最大值限制,即所有超过核心线程数的任务都将被添加到队列中,这也就导致了maximumPoolSize的设定失效,因为总线程数永远不会超过corePoolSize>> 3. ArrayBlockingQueue:可以限定队列的长度,接收到任务的时候,如果没有达到corePoolSize的值,则新建线程(核心线程)执行任务,如果达到了,则入队等候,如果队列已满,则新建线程(非核心线程)执行任务,又如果总线程数到了maximumPoolSize,并且队列也满了,则发生错误>> 4. DelayQueue:队列内元素必须实现Delayed接口,这就意味着你传进去的任务必须先实现Delayed接口。

这个队列接收到任务时,首先先入队,只有达到了指定的延时时间,才会执行任务• ThreadFactory threadFactory>创建线程的方式,这是一个接口,你new他的时候需要实现他的这是星期六,休息> >但我还是说一句吧(把枪放下...)>>小伙伴应该知道AsyncTask是对线程池的封装吧?那就直接放一个AsyncTask新建线程池的threadFactory参数源码吧:>> ```> newThreadFactory() {> private finalAtomicInteger mCount = newAtomicInteger(1);>> public Thread new Thread(Runnable r){> return newThread(r,"AsyncTask #"+ mCount.getAndIncrement());> }> }> ```>这么简单?就给线程起了个名?!• RejectedExec utionHandlerhandler>这玩意儿就是抛出异常专用的,比如上面提到的两个错误发生了,就会由这个handler抛出异常,你不指定他也有个默认的>新建一个线程池的时候,一般只用5个参数的构造函数。

向ThreadPoolExecutor 添加任务那说了这么多,你可能有疑惑,我知道new 一个ThreadPoolExecutor,大概知道各个参数是干嘛的,可是我new完了,怎么向线程池提交一个要执行的任务啊?通过ThreadPoolExecutor.execute(Runnable command) 方法即可向线程池内添加一个任务ThreadPoolExecutor 的策略上面介绍参数的时候其实已经说到了ThreadPoolExecutor执行的策略,这里给总结一下,当一个任务被添加进线程池时:1.线程数量未达到corePoolSize,则新建一个线程(核心线程)执行任务2.线程数量达到了corePools,则将任务移入队列等待3.队列已满,新建线程(非核心线程)执行任务4.队列已满,总线程数又达到了maximumPoolSize,就会由上面那位星期天(RejectedExecutionHandler)抛出异常三.、常见四种线程池如果你不想自己写一个线程池,那么你可以从下面看看有没有符合你要求的(一般都够用了),如果有,那么很好你直接用就行了,如果没有,那你就老老实实自己去写一个吧Java 通过Executors 提供了四种线程池,这四种线程池都是直接或间接配置ThreadPoolExecutor 的参数实现的,下面我都会贴出这四种线程池构造函数的源码,各位大佬们一看便知!来,走起:CachedThreadPool()可缓存线程池:1.线程数无限制2.有空闲线程则复用空闲线程,若无空闲线程则新建线程3.一定程序减少频繁创建/销毁线程,减少系统开销创建方法:ExecutorServicecachedThreadPool = Executors.newCachedThreadPool();源码:public static ExecutorServicenewCachedThreadPool() {return newThreadPoolExecutor(0,Integer.MAX_VALUE,60L,TimeUnit.SECONDS,newSynchronousQueue<Runnable>());}通过我上面行云流水谈笑风生天马行空滔滔不绝的对各种参数的说明,这个源码你肯定一眼就看懂了,想都不用想(下面三种一样啦)FixedThreadPool()定长线程池:1.可控制线程最大并发数(同时执行的线程数)2.超出的线程会在队列中等待创建方法://nThreads =>最大线程数即maximumPoolSizeExecutorServicefixedThreadPool =Executors.newFixedThreadPool(int nThreads);//threadFactory =>创建线程的方法,这就是我叫你别理他的那个星期六!你还看!ExecutorServicefixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactorythreadFactory);源码:public static ExecutorServicenewFixedThreadPool(int nThreads){ return new ThreadPoolExecutor(nThreads,nThreads, 0L,LISECONDS, newLinkedBlockingQueue<Runnable>());}2个参数的构造方法源码,不用我贴你也知道他把星期六放在了哪个位置!所以我就不贴了。

相关文档
最新文档