并发编程 | 线程池的自动创建

于 2024-08-15 18:51:36 发布
阅读量1k 收藏 20
点赞数 24
分类专栏： Java进阶之路 文章标签： java 服务器 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42627385/article/details/141229481
版权

自动创建线程池

前面介绍了通过ThreadPoolExecutor类可以创建出我们想要的线程池，但需要我们精准的控制各个参数，如果嫌麻烦，其实JDK给我们提供了一些常用的线程池，我们直接拿来用就可以了，这种通过Executors类的各种方法创建线程池的方式也叫自动创建线程池。

下面介绍常见的几种自动创建线程池的方式。

FixedThreadPool

FixedThreadPool底层也是通过ThreadPoolExecutor类创建的，通过源码可以看出FixedThreadPool特点：核心线程数和最大线程数相等；同时其任务队列又是一个无界的任务队列。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>());
}

下面是一个使用FixedThreadPool线程池示例：

lass MyRunnable implements Runnable{
    private int i;
    MyRunnable(int i){
        this.i = i;
    }

    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " 线程"  + Thread.currentThread().getName() + " 执行任务" + i);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}class ThreadPoolExecutorTest{
    public void testNewFixedThreadPool(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i=0; i<6; i++){
            executorService.submit(new MyRunnable(i));
        }
    }
}

public class ThreadPoolExecutorExample {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutorTest threadPoolExecutorTest = new ThreadPoolExecutorTest();
        threadPoolExecutorTest.testNewFixedThreadPool();
    }
}

//输出
22/06/25-11:18:47 线程pool-1-thread-1 执行任务0
22/06/25-11:18:47 线程pool-1-thread-3 执行任务2
22/06/25-11:18:47 线程pool-1-thread-2 执行任务1
22/06/25-11:18:49 线程pool-1-thread-2 执行任务4
22/06/25-11:18:49 线程pool-1-thread-1 执行任务3
22/06/25-11:18:49 线程pool-1-thread-3 执行任务5

在上面的程序中，创建了一个线程数为3的newFixedThreadPool类型线程池，然后提交了6个任务，任务的运行时间是2s。

通过程序的运行结果可以看出，11:18:47 时刻当六个任务提交时，只会马上创建三个线程（线程1,2,3）分别执行其中的三个任务（任务0,2,1），而另外三个任务（任务4,3,5）则会放在任务队列中，只有等到原来创建的线程执行完任务之后才会接着从任务队列取出任务继续执行，所以任务4,3,5的执行时间是11:18:49 。

SingleThreadExecutor

SingleThreadExecutor类型线程池可以看做是线程数为1的FixedThreadPool线程池。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                   0L, TimeUnit.MILLISECONDS,
                   new LinkedBlockingQueue<Runnable>()));
}

下面是一个使用SingleThreadExecutor线程池示例：

class MyRunnable implements Runnable{
    private int i;
    MyRunnable(int i){
        this.i = i;
    }

    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " 线程"  + Thread.currentThread().getName() + " 执行任务" + i);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadPoolExecutorTest{
    public void testNewSingleThreadExecutor() throws InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i=0; i<6; i++){
            executorService.submit(new MyRunnable(i));
        }
    }
}

public class ThreadPoolExecutorExample {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutorTest threadPoolExecutorTest = new ThreadPoolExecutorTest();
        threadPoolExecutorTest.testNewSingleThreadExecutor();
    }
}

//输出
22/06/25-15:09:46 线程pool-1-thread-1 执行任务0
22/06/25-15:09:48 线程pool-1-thread-1 执行任务1
22/06/25-15:09:50 线程pool-1-thread-1 执行任务2
22/06/25-15:09:52 线程pool-1-thread-1 执行任务3
22/06/25-15:09:54 线程pool-1-thread-1 执行任务4
22/06/25-15:09:56 线程pool-1-thread-1 执行任务5

在上面的程序中，创建了一个SingleThreadExecutor类型线程池，然后提交了6个任务，任务的运行时间是2s。

通过程序的运行结果可以看出，当六个任务提交时，只会创建1个线程（线程1）执行第一个提交的任务（任务0），而另外五个任务（任务1,2,3,4,5）则会放在任务队列中，只有等到执行完前面任务之后才会接着从任务队列取出1个任务继续执行，直到所有任务执行完毕，所以后面任务开始执行的时刻都比前面的任务执行时刻晚2s 。

CachedThreadPool

CachedThreadPool类型线程池通过构造函数可以看出其特点：corePoolSize设置为0，maxPoolSize设置为整型的最大值，任务队列用的是容量为0的SynchronousQueue队列。任务队列中并不实质存储任务，而是直接交给线程去执行，因此线程池需要不断创建线程来处理提交过来的任务。

ublic static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                   60L, TimeUnit.SECONDS,
                   new SynchronousQueue<Runnable>());
}

下面是一个使用CachedThreadPool线程池示例：

class MyRunnable implements Runnable{
    private int i;
    MyRunnable(int i){
        this.i = i;
    }

    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " 线程"  + Thread.currentThread().getName() + " 执行任务" + i);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadPoolExecutorTest{
    public void testCachedThreadPool(){
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0; i<6; i++){
            executorService.submit(new MyRunnable(i));
        }
    }
}

public class ThreadPoolExecutorExample {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutorTest threadPoolExecutorTest = new ThreadPoolExecutorTest();
        threadPoolExecutorTest.testCachedThreadPool();
    }
}

//输出
22/06/25-15:20:48 线程pool-1-thread-2 执行任务1
22/06/25-15:20:48 线程pool-1-thread-3 执行任务2
22/06/25-15:20:48 线程pool-1-thread-5 执行任务4
22/06/25-15:20:48 线程pool-1-thread-1 执行任务0
22/06/25-15:20:48 线程pool-1-thread-6 执行任务5
22/06/25-15:20:48 线程pool-1-thread-4 执行任务3

在上面的程序中，创建了一个CachedThreadPool类型线程池，然后提交了6个任务，任务的运行时间是2s。

通过程序的运行结果可以看出，当六个任务提交时，是在15:20:48时刻六个任务同时执行的，说明这种类型的线程池每次来了任务就新建线程。

ScheduledThreadPool

ScheduledThreadPool类型线程池支持定时或周期性执行任务。比如每隔 10 秒钟执行一次任务，而实现这种功能的方法主要有 3 种，如代码所示：

//延迟指定时间后执行一次指定的任务
schedule(new MyRunnable(), 4, TimeUnit.SECONDS)

//第一次延时4s执行一次指定任务，然后每隔3s执行一次指定任务
scheduleAtFixedRate(new MyRunnable(), 4, 3, TimeUnit.SECONDS);

//第一次延时4s执行一次指定任务，然后每隔3s执行一次指定任务
scheduleWithFixedDelay(new MyRunnable(), 4, 3, TimeUnit.SECONDS);

下面是一个使用ScheduledThreadPool线程池示例：

class MyRunnable implements Runnable{
    private int i;
    MyRunnable(int i){
        this.i = i;
    }
    
   MyRunnable(){
        this.i = 8;
    }

    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " 线程"  + Thread.currentThread().getName() + " 执行任务" + i);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadPoolExecutorTest{
    public void testScheduledThreadPool1(){
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
        executorService.schedule(new MyRunnable(), 4, TimeUnit.SECONDS);
    }
}

public class ThreadPoolExecutorExample {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutorTest threadPoolExecutorTest = new ThreadPoolExecutorTest();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " main 开始运行");
        
        threadPoolExecutorTest.testScheduledThreadPool1();
    }
}

//输出
22/06/25-15:58:13 main 开始运行
22/06/25-15:58:17 线程pool-1-thread-1 执行任务8

在上面的程序中，创建了一个ScheduledThreadPool类型线程池，然后调用schedule方法，通过程序的运行结果可以看出，main运行后的4s执行了一次指定的任务。注意这个方法只会执行一次任务，后续就不会再执行该任务了。

要想周期性的执行指定的任务，则需要用到上面介绍的第2种或第3种方法，先看看第二种方法scheduleAtFixedRate，如下示例：

class MyRunnable implements Runnable{
    private int i;
    MyRunnable(int i){
        this.i = i;
    }
    
   MyRunnable(){
        this.i = 8;
    }

    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " 线程"  + Thread.currentThread().getName() + " 执行任务" + i);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadPoolExecutorTest{
    public void testScheduledThreadPool2(){
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
        executorService.scheduleAtFixedRate(new MyRunnable(), 4, 3, TimeUnit.SECONDS);
    }
}

public class ThreadPoolExecutorExample {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutorTest threadPoolExecutorTest = new ThreadPoolExecutorTest();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " main 开始运行");
        
        threadPoolExecutorTest.testScheduledThreadPool2();
    }
}

//输出
22/06/25-16:04:50 main 开始运行
22/06/25-16:04:54 线程pool-1-thread-1 执行任务8
22/06/25-16:04:57 线程pool-1-thread-1 执行任务8
22/06/25-16:05:00 线程pool-1-thread-1 执行任务8
22/06/25-16:05:03 线程pool-1-thread-1 执行任务8
22/06/25-16:05:06 线程pool-1-thread-1 执行任务8

通过程序的运行结果可以看出，调用scheduleAtFixedRate执行周期任务，这个周期是以任务开始的时间为时间起点开始计时，时间到就开始执行第二次任务，不管任务的执行时间，如本例我设置的周期是3s，那么第一次执行任务的时间是16:04:54 ， 那么过3s之后也就是16:04:57时刻第二次执行任务，以此类推周期执行。

我们再看看使用第三种方法scheduleWithFixedDelay执行周期任务，如下示例：

class MyRunnable implements Runnable{
    private int i;
    MyRunnable(int i){
        this.i = i;
    }
    
   MyRunnable(){
        this.i = 8;
    }

    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " 线程"  + Thread.currentThread().getName() + " 执行任务" + i);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadPoolExecutorTest{
    public void testScheduledThreadPool3(){
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
        executorService.scheduleWithFixedDelay(new MyRunnable(), 4, 3, TimeUnit.SECONDS);
    }
}

public class ThreadPoolExecutorExample {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutorTest threadPoolExecutorTest = new ThreadPoolExecutorTest();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " main 开始运行");
        
        threadPoolExecutorTest.testScheduledThreadPool3();
    }
}

//输出
22/06/25-16:07:03 main 开始运行
22/06/25-16:07:07 线程pool-1-thread-1 执行任务8
22/06/25-16:07:12 线程pool-1-thread-1 执行任务8
22/06/25-16:07:17 线程pool-1-thread-1 执行任务8
22/06/25-16:07:22 线程pool-1-thread-1 执行任务8

通过程序的运行结果可以看出，调用scheduleWithFixedDelay执行周期任务，这个周期是以上次任务结束的时间为起点开始计时，因此定时的周期不但和设置的参数有关，还和任务的执行时间有关，如本例我设置的周期是3s，任务的执行时间是2s，那么第一次执行任务的时间是16:07:07， 任务执行了2s在16:07:09结束第一次任务,那么在16:07:09的基础上再过3s之后也就是16:07:12 时刻第二次执行任务，以此类推周期执行。

SingleThreadScheduledExecutor

线程池SingleThreadScheduledExecutor只是 ScheduledThreadPool 的一个特例，内部只有一个线程。

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
    return new DelegatedScheduledExecutorService
        (new ScheduledThreadPoolExecutor(1));

}

不应该自动创建线程池

在实际开发中，其实是不建议自动创建线程池的，因为自动创建线程池是有一定风险的，下面针对每一种自动创建线程池的方式来分析其可能带来哪些问题。

FixedThreadPool

FixedThreadPool是线程数量固定的线程池，使用的队列是容量没有上限的LinkedBlockingQueue，设想一种场景：如果任务的处理速度比较慢，而提交的任务很多，那么任务队列中堆积的任务也会越来越多，最终大量堆积的任务会占用大量内存，并发生OOM，会对整个程序造成很严重的影响。SingleThreadExecutor线程池其任务队列也是是无界的，所以存在的问题和FixedThreadPool线程池一样。

CachedThreadPool

CachedThreadPool线程池的最大线程数被设置成了Integer.MAX_VALUE，所以当任务数量特别多的时候，就可能会导致创建非常多的线程，最终超过了操作系统的上限而无法创建新线程，或者导致内存不足。

ScheduledThreadPool

ScheduledThreadPool和SingleThreadScheduledExecutor线程池采用的任务队列是 DelayedWorkQueue，这是一个延迟队列，同时也是一个无界队列，所以和 LinkedBlockingQueue 一样，如果队列中存放过多的任务，也可能会导致OOM。纵上所述，这几种自动创建的线程池都存在风险，相比较而言，我们自己手动创建会更好，因为我们可以更加明确线程池的运行规则，不仅可以选择适合自己的线程数量，更可以在必要的时候拒绝新任务的提交，避免资源耗尽的风险。

一个OOM例子

下面程序模拟出通过newFixedThreadPool创建线程池造成OOM的场景:

class MyRunnables implements Runnable{
    private long[] arr = new long[10000];
    @Override
    public void run() {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy/MM/dd-HH:mm:ss");
        String time = simpleDateFormat.format(new Date());
        System.out.println(time + " 线程"  + Thread.currentThread().getName() + " 执行任务");
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadPoolOOMtest{
    public void testNewFixedThreadPoolOOM(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i=0; i<6000000; i++){
            executorService.submit(new MyRunnables());
        }
    }
}

public class ThreadPoolOOMExample {
    public static void main(String[] args) {
        ThreadPoolOOMtest threadPoolOOMtest = new ThreadPoolOOMtest();
        threadPoolOOMtest.testNewFixedThreadPoolOOM();
    }
}

//输出
22/06/25-17:14:05 线程pool-1-thread-1 执行任务
22/06/25-17:14:05 线程pool-1-thread-3 执行任务
22/06/25-17:14:05 线程pool-1-thread-2 执行任务

Exception: java.lang.OutOfMemoryError thrown from the UncaughtExceptionHandler in thread "main"

该程序中，任务执行时间20s,提交了6000000个任务，而线程池线程数量为3，那么20s内，只有3个任务在执行，其他的任务被提交到任务队列中，最后导致占用大量内存，发生 OOM现象。

Java必知必会系列：并发编程与线程池
程序员光剑
10-20 285
多核CPU、超级计算机、高速网络带宽等信息技术的飞速发展，给开发人员带来了巨大的生产力提升。随之而来的新一代的应用场景也引起了软件工程师们的高度重视，包括分布式计算、实时计算、并行计算等。这些应用场景都要求开发人员需要对硬件资源进行更加精细化的管理，比如为每一个请求分配不同的线程，合理利用线程池中的线程资源；并且还需要高效地处理并发事务，确保服务的稳定性和可用性。本文将从多种角度讨论并发编程与线程池在软件开发中的作用及其相关技术原理。
Java并发编程：线程池
rrq_0324的博客
12-04 1125
1. 基础知识 1.1 线程池的特点 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。（线程复用） 提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。（控制最大并发数） 1.2 异步回调 同步和异步通常用来形容一次方法调用。 同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。 异步方法调用一旦开始，方法调
Java线程池体系（超详细）【从0到自定义线程池】
m0_52226803的博客
12-25 2703
是 Java 中的一个抽象类，它是接口的一个实现。提供了一些默认实现，以简化的实现要实现很多方法的问题。①自定义工具类。包装自定义线程池，对外提供静态方法方便使用。这里为了方便测试，核心线程1，最大线程10，缓存队列10，该线程池最大接收20个任务static {@Overridereturn t;@Override。
线程池使用之自定义线程池
qq_61313896的博客
09-21 950
线程池使用之自定义线程池
自己动手写一个线程池
qq_52467117的博客
02-13 1450
问题 （1）自己动手写一个线程池需要考虑哪些因素？ （2）自己动手写的线程池如何测试？ 简介 线程池是Java并发编程中经常使用到的技术，那么自己如何动手写一个线程池呢？本文彤哥将手把手带你写一个可用的线程池。 属性分析 线程池，顾名思义它首先是一个“池”，这个池里面放的是线程，线程是用来执行任务的。 首先，线程池中的线程应该是有类别的，有的是核心线程，有的是非核心线程，所以我们需要两个变量标识核心线程数量coreSize和最大线程数量maxSize。 为什么要区分是否为核心线程呢？这是为了
自定义线程池
eyes++的博客
04-03 7265
一：参数分析 我们要想自定义线程池，必须先了解线程池的工作流程，才能自己定义线程池。下图是ThreadPoolExecutor的构造方法。 我们可以通过下面的场景理解ThreadPoolExecutor中的各个参数; a客户(任务)去银行(线程池)办理业务,;但银行刚开始营业,窗口服务员还未就位(相当于线程池中初始线程数量为0)于是经理(线程池管理者)就安排1号工作人员(创建1号线程执行任务)接待a客户(创建线程); 在a客户业务还没办完时,b客户(任务)又来了,于是经理(线程池管理者)就安排2号工作人员
Java 多线程之自定义线程池（ThreadPool）使用方法
QIFU的专栏
12-22 3866
线程池是一种管理和复用线程的机制，它包含一组预先创建的线程，用于执行各种任务。线程池的主要作用是提高多线程应用程序的性能和效率，并提供对线程的生命周期和资源的管理，包括线程的创建、销毁和复用。本文主要讨论线程池执行器（ThreadPoolExecutor）的用法，在观看本文之前建议先看线程池使用入门。
Java并发编程：线程池的使用与优化
在现代的软件开发中，并发编程是一个非常重要的主题。随着计算机处理能力的提升，越来越多的应用需要同时处理多个任务或请求，以提高系统的性能和响应能力。然而，并发编程也带来了一些挑战，例如线程安全性、资源...
为师妹写的《Java并发编程之线程池十八问》被表扬啦！
JavaBuild的博客
05-29 1170
所谓 线程池，就是一个可以管理若干线程的容器，当有任务需要处理时，会提交到线程池的任务队列中，由线程池分配空闲的线程处理任务，处理完任务的线程不会被销毁，而是在线程池中等待下一个任务。
如何自定义线程池
sinat_42853417的博客
09-04 3507
一，要自定义线程池，需要使用的ThreadPoolExecutor类 .ThreadPoolExecutor类的构造方法： public ThreadPoolExecutor（int coreSize，int maxSize，long KeepAliveTime，TimeUnit unit，BlockingQueue queue，ThreadFactory fa...
自定义实现Java线程池
09-22
自定义实现Java线程池,学习大师设计思想,瞻仰大神笔法
SpringBoot 自定义线程池
适恒
07-03 1万+
1.我们都知道spring只是为我们简单的处理线程池，每次用到线程总会new 一个新的线程，效率不高，所以我们需要自定义一个线程池。 2.自定义线程池有两种方法，第一种自定义线程池然后使用自己的自定义的，第二种重写spring默认的线程池，然后使用自己重写过的线程池 一：自定义线程池 1.1 修改application.yml #线程池配置参数 task: pool: cor...
【Java】一文看懂Thread 线程池的 7 种创建方式、任务队列及自定义线程池（代码示例）
最新发布
06-02 1万+
【Java】一文看懂Thread 线程池的 7 种创建方式、任务队列及自定义线程池（代码示例）
并发编程系列之自定义线程池
姑苏城外（り寂寞
06-21 1万+
前言 前面我们在讲并发工具类的时候，多次提到线程池，今天我们就来走进线程池的旅地，首先我们先不讲线程池框架Executors，我们今天先来介绍如何自己定义一个线程池，是不是已经迫不及待了，那么就让我们开启今天的旅途吧。 什么是线程池？ 线程池可以理解为一个专门管理线程生命周期的池子，里面的线程都可以由这个池子本身来调度，使用线程池有哪些好处呢？ 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗 提高响应速度：当任务到达时，任务可以不需要的等到线程创建就能立即执行.
【详解】线程池及其自定义线程池的实现
Money、坤的博客
07-08 2106
1. 为什么使用线程池？线程池是运用场景最多的并发框架，几乎所有需要一步或者并发执行任务的程序都可以使用线程池。使用线程池一般有以下三个好处：①降低资源的消耗，通过重复利用已经创建的线程降低线程创建和销毁造成的消耗。②提高相应速度，当任务到达的时候，任务可以不需要等到线程创建就能立刻执行。③提高线程的可管理性，线程是稀缺资源，使用线程池可以统一的分配、调优和监控。2. Java中的线程池ThreadPool 线程池参数介绍 1）corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程
实现自定义线程池
Sumuxi9797926的博客
11-13 1008
尝试着自己写一个线程池加深对JDK线程池的理解，从阻塞队列出发，协调任务的产生与线程池消费任务，用ReentrantLock锁技术，对阻塞队列是否已满，为空等情况进行阻塞挂起线程；再设计线程池，围绕任务的执行execute，与队列实现一些拒绝策略等等
【Thread】线程池的 7 种创建方式及自定义线程池
热门推荐
sco5282的博客
11-06 2万+
1. 什么是线程池 线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制。它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。 使用线程池主要有以下优点： 降低资源消耗 提高响应速度 提高线程的可管理性 同时，阿里巴巴在其《Java开发手册》中也强制规定：线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 2. 使用线程池 线程池的创建方法总共有 7 种，但总体来说可分为 2 类：
Java并发编程深度解析：线程池与锁机制
3. 自动创建线程池可能导致资源浪费和管理困难，应根据具体需求手动配置。 4. 合适的线程数量通常基于CPU核心数、任务类型和系统负载等因素确定，一般推荐略高于CPU核心数。 5. 定制线程池需考虑核心线程数、最大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值