Java 线程池的创建——7种方法

最新推荐文章于 2025-06-16 23:02:40 发布
原创 最新推荐文章于 2025-06-16 23:02:40 发布 · 1.9w 阅读 · 87 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #intellij-idea

本文详细介绍了Java中通过Executors和ThreadPoolExecutor创建线程池的多种方式，包括newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor、newScheduledThreadPool、newWorkStealingPool等，分析了它们的特点和适用场景，并探讨了线程池的优势和拒绝策略。同时，展示了如何手动创建线程池及其参数配置，以及不同的拒绝策略行为。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线程池的创建分为两大类方法

  • 通过Executors自动创建
  • 通过ThreadPoolExecutor手动创建

Executors创建线程池的方法——6种

  1. newFixedThreadPool：创建一个固定大小的线程池
public class ThreadPool1 {
    public static void main(String[] args) {
        //1.创建一个大小为5的线程池
        ExecutorService threadPool= Executors.newFixedThreadPool(5);
        //2.使用线程池执行任务一
        for (int i=0;i<5;i++){
            //给线程池添加任务
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名"+Thread.currentThread().getName()+"在执行任务1");
                }
            });
        }
        //2.使用线程池执行任务二
        for (int i=0;i<8;i++){
            //给线程池添加任务
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名"+Thread.currentThread().getName()+"在执行任务2");
                }
            });
        }

    }
}

结果：
在这里插入图片描述

  1. newCachedThreadPool：带缓存的线程池，适用于短时间有大量任务的场景，但有可能会占用更多的资源；线程数量随任务量而定。
public class ThreadPool3 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service= Executors.newCachedThreadPool();
        //有50个任务
        for(int i=0;i<50;i++){
            int finalI = i;
            service.submit(()->{
                System.out.println(finalI +"线程名"+Thread.currentThread().getName());//线程名有多少个，CPU就创建了多少个线程
            });
        }
    }
}

结果：
执行了两次：一次有18个线程，一次有19个线程；线程的数量由cpu根据任务量而定。

  1. newSingleThreadExecuto:创建单个线程的线程池

创建单个线程的线程池？为啥不直接创个线程？

  • 线程池的优点：
  • 1.复用线程：不必频繁创建销毁线程
  • 2.也提供了任务队列和拒绝策略
public class ThreadPool4 {
    public static void main(String[] args) {
        ExecutorService service= Executors.newSingleThreadExecutor();
        for (int i=0;i<5;i++){
            int finalI = i;
            service.submit(()->{
                System.out.println(finalI +"线程名"+Thread.currentThread().getName());//CPU只创建了1个线程，名称始终一样
            });
        }
    }
}

结果：
在这里插入图片描述

  1. newSingleThreadScheduledExecutor：创建执行定时任务的单个线程的线程池
public class ThreadPool5 {
    public static void main(String[] args) {
        ScheduledExecutorService service= Executors.newSingleThreadScheduledExecutor();
        System.out.println("添加任务："+ LocalDateTime.now());
        service.schedule(new Runnable() {

                @Override
                public void run() {
                    System.out.println("执行任务："+LocalDateTime.now());
                }
            },3,TimeUnit.SECONDS);//推迟3秒执行任务
    }
}

结果：时间相差 3s
在这里插入图片描述

  1. newScheduledThreadPool：创建执行定时任务的线程池
/**
 * 创建执行定时任务的线程池
 */
public class ThreadPool6 {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);//5个线程
        System.out.println("添加任务：" + LocalDateTime.now());
        //once(service);
        many(service);
    }
    /**
     * 执行一次的定时任务
     */
    public static void once(ScheduledExecutorService service) {
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务:"+ LocalDateTime.now());
            }
        },3, TimeUnit.SECONDS);//推迟3秒执行
    }
}

执行一次的定时任务 的结果：

在这里插入图片描述
当执行多次的定时任务——scheduleWithFixedDelay

//2.推迟3秒执行;上一次任务结束2s后，下一个任务开始执行
        service.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务:"+ LocalDateTime.now()+"线程名"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000*2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },3,2,TimeUnit.SECONDS);//间隔时间成了4s；因为线程休眠了2s

在这里插入图片描述
当执行多次的定时任务——scheduleAtFixedRate

//1.推迟3秒执行;上一次任务开始2s后，下一个任务开始执行
       service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务:"+ LocalDateTime.now()+"线程名"+Thread.currentThread().getName());
                try {
                    //1.间隔时间>执行时间;以间隔时间为准
                    Thread.sleep(100);
                    //2.执行时间>间隔时间;以执行时间为准
                    Thread.sleep(1000*3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },3,2,TimeUnit.SECONDS);

1.间隔时间2s>执行时间0.1s;以间隔时间为准
在这里插入图片描述

2.执行时间3s>间隔时间2s;以执行时间为准
在这里插入图片描述

  1. newWorkStealingPool：根据当前设备的配置自动生成线程池
public class ThreadPool7 {
    public static void main(String[] args) {
        ExecutorService service= Executors.newWorkStealingPool();
        for(int i=0;i<50;i++){
            int finalI = i;
            service.submit(()->{
                System.out.println(finalI +"线程名"+Thread.currentThread().getName());//线程名有多少个，CPU就创建了多少个线程
            });
        }
        //创建的为守护线程，JVM不会等待守护线程结束
        while (!service.isTerminated()){

        }
    }
}

根据自身电脑配置决定创建的线程数目

ThreadPoolExecutor——7.手动创建线程池

public class ThreadPool9 {
    public static void main(String[] args) {
        //线程工厂
        ThreadFactory factory=new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread=new Thread(r);

                return thread;
            }
        };
        //手动创建线程池
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(2), factory,
                //1.提示异常，拒绝执行多余的任务
               // new ThreadPoolExecutor.AbortPolicy()

                //2.忽略堵塞队列中最旧的任务
                //new ThreadPoolExecutor.DiscardOldestPolicy()

                //3.忽略最新的任务
                //new ThreadPoolExecutor.DiscardPolicy()

                //4.使用调用该线程池的线程来执行任务
                //new ThreadPoolExecutor.CallerRunsPolicy()

                //5.A自定义拒绝策略
                new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println("拒绝策略");
            }
        }
        );
        //任务
        for (int i=0;i<7;i++){
            int finalI=i;
            threadPoolExecutor.submit(()->{
                try {
                    Thread.sleep(finalI*100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"任务名"+finalI);
            });
        }
        
    }
}

在这里插入图片描述
7种参数分别是：

  • 核心（最少）线程数

  • 最大线程数

  • 闲置可存活时间

  • 描述（闲置可存活时间）的单位

  • 任务队列

  • 线程工厂

  • 拒绝策略有5种：

             //1.提示异常，拒绝执行多余的任务
        // new ThreadPoolExecutor.AbortPolicy()
        
        //2.忽略堵塞队列中最旧的任务
         //new ThreadPoolExecutor.DiscardOldestPolicy()

         //3.忽略最新的任务
         //new ThreadPoolExecutor.DiscardPolicy()

         //4.使用调用该线程池的线程来执行任务
         //new ThreadPoolExecutor.CallerRunsPolicy()

         //5.自定义拒绝策略
         new RejectedExecutionHandler()
xhhhx_
关注
【Java 中创建线程池的方式】
高克莱的博客
05-15 1870
在Java中，创建线程池通常推荐使用ThreadPoolExecutor类进行自定义配置，因为这样可以根据实际需求精细调整线程池的行为，以避免使用Executors类的静态方法创建线程池可能带来的潜在问题，如内存泄漏风险或资源耗尽。
Java 创建线程池的几种方式
精神小牛马
07-18 7409
java线程池创建的几种方式和运用
Java 自己实现线程池
12-13
Java开发，Android开发，自己实现线程池，明白线程池的实现机制
Java如何创建线程池
程序员猫爪
04-27 3764
这将创建一个线程池，线程数量可自动调整，通常无界。空闲线程将在一段时间后被回收，当任务提交时，若没有可用线程则会创建新线程。类的静态工厂方法创建线程池并不总是推荐，因为它们可能导致线程池配置过于简单，无法精细控制，尤其是在面临高并发场景或需要防止资源滥用时。构造方法创建线程池，您可以更精确地配置线程池行为，更好地应对特定应用的需求和潜在的并发问题，符合最佳实践建议。创建一个仅包含一个线程的线程池，所有任务按照提交顺序依次执行。创建一个支持定时及周期性任务执行的线程池，核心线程数由。
线程池（Thread Pool）详解
最新发布
weixin_54062440的博客
06-16 1287
避免频繁创建和销毁线程带来的性能开销。在高并发场景（如Web服务器、微服务调用等）中，合理使用线程池能显著提升系统性能和稳定性。掌握线程池是Java高并发编程的基础，也是面试高频考点。）和实际场景（如Web服务器请求处理）加深理解。线程池是Java多线程编程中的核心组件，用于。无限制创建线程会导致资源耗尽（如内存溢出）。接口及其实现类提供线程池支持，核心实现类是。线程池的拒绝策略有哪些？，立即创建新线程执行任务。如果队列和线程池均满，触发。，创建临时线程执行任务。线程池的底层原理是什么？
Java 创建线程池有哪些方式？
qq_63553317的博客
03-01 1103
每个线程都有自己的任务队列，当一个线程的任务队列为空时，它会从其他线程的任务队列中 “窃取” 任务来执行。创建一个可缓存的线程池，核心线程数为 0，最大线程数无界 (Integer.MAX_VALUE)。是 Java 7 引入的一种特殊的线程池，它实现了 work-stealing 算法，适合于执行可以分解为多个子任务的计算密集型任务。是 Java 并发包中最核心的线程池实现类，它提供了丰富的构造方法和参数，可以更精细地控制线程池的行为。创建一个单线程的线程池，核心线程数和最大线程数都为 1。
线程池——线程池创建的5种方法
qq_44891295的博客
04-13 1447
文章目录1 newFixedThreadPool 方法2 newSingleThreadExcutor方法3 newCachedThreadPool方法4 newSingleThreadScheduledExecutor方法5 newScheduledThreadPool方法 1 newFixedThreadPool 方法 newFixedThreadPool() 方法：该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的
java多线程——线程池
oopxiajun博客专栏
11-25 1620
在Java中，线程池是一种用于管理和复用线程的技术，它可以减少创建和销毁线程的开销，提高系统的性能和响应速度。Java标准库提供了包，其中包含了接口及其实现类，用于创建和管理线程池。
十二、连接池线程池配置——线程池
流楚丶格念的博客
08-27 1427
如果需要在 Spring Boot 中创建自定义线程池（例如用于特定的任务或服务），可以使用。
深探Java线程池协同神器——CountDownLatch的源码奥秘与实战应用
m0_51176516的博客
06-20 1749
CountDownLatch以其简洁高效的设计理念和强大的功能，成为Java多线程编程中的一大利器。通过对其源码的深入分析，不仅能更好地理解其工作原理，还能在实际应用中更加灵活、高效地使用它。在工程师的眼中，CountDownLatch不仅是一个线程同步工具，更是一个实现线程间高效协同的神器。
Java 异步编程——常用线程池 ThreadPoolExecutor
longool的博客
10-18 1196
默认情况下，只有当线程池中的线程数大于 corePoolSize 时，keepAliveTime 才会起作用，直到线程池中的线程数不大于 corePoolSize，即当线程池中的线程数大于 corePoolSize 时，如果一个线程空闲的时间达到 keepAliveTime，则会终止，直到线程池中的线程数不超过 corePoolSize。【注：每一个线程在获取锁的时候可能都会排队等待，如果在等待时间上，先获取锁的线程的请求一定先被满足，那么这个锁就是公平的。容量为0，不存储任何元素，即没有数据缓存的空间。
100行Java代码构建一个线程池
龙的天空
10-15 1139
　　在现代的操作系统中，有一个很重要的概念――线程，几乎所有目前流行的操作系统都支持线程，线程来源于操作系统中进程的概念，进程有自己的虚拟地址空间以及正文段、数据段及堆栈，而且各自占有不同的系统资源（例如文件、环境变量等等）。与此不同，线程不能单独存在，它依附于进程，只能由进程派生。如果一个进程派生出了两个线程，那这两个线程共享此进程的全局变量和代码段，但每个线程各拥有各自的堆栈，因此
面试突击：线程池有几种创建方式？推荐使用哪种？
热门推荐
HongYu012的博客
03-07 1万+
在 Java 语言中，并发编程都是通过创建线程池来实现的，而线程池的创建方式也有很多种，每种线程池的创建方式都对应了不同的使用场景，总体来说线程池的创建可以分为以下两类： 通过 ThreadPoolExecutor 手动创建线程池。 通过 Executors 执行器自动创建线程池。 而以上两类创建线程池的方式，又有 7 种具体实现方法，这 7 种实现方法分别是： Executors.newFixedThreadPool：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。.
java线程池的创建
weixin_43080791的博客
10-13 2519
java线程池创建的7种方式
java创建线程池
doncai的专栏
08-22 3016
 1. PoolTest(测试类)实现了Runnable接口，在构造函数中创建ThreadPool(线程池类)对象；   执行任务runTask，将线程从Vector freeThreads转移到Vector inUseThreads，并调用PoolableThread的setTask。2. ThreadPool在构造函数中，创建了10个PoolableThread(控制线程类)，start线程，
Java线程与创建Java程序中的线程池
cool_rain_man的专栏
09-27 584
Java线程与如何创建Java程序中的线程池线程是Java的一大特性，它可以是给定的指令序列、给定的方法中定义的变量或者一些共享数据(类一级的变量)。在Java中每个线程有自己的堆栈和程序计数器（PC），其中堆栈是用来跟踪线程的上下文（上下文是当线程执行到某处时，当前的局部变量的值），而程序计数器则用来跟踪当前线程正在执行的指令。 在通常情况下，一个线程不能访问另外一个线程的堆
Java创建线程池的方式
zxyhj的博客
10-18 1590
线程池工作核心流程：1、先判读当前线程数是否小于 corePoolSize。如果小于就新建线程执行2、如果大于，就判断阻塞队列是否已经满了，如果没有满，就加入阻塞队列中。3、如果满了，就判断当前线程数是否小于 maxPoolSize。如果小于，就直接创建线程执行。如果大于就根据拒绝策略，拒绝任务。拒绝策略线程池有四种拒绝策略1、丢弃任务，并抛出异常2、丢弃任务，单不抛出异常3、丢弃队列最前面的任务，然后重新提交当前任务。4、线程池什么都不做，由当前线程自己处理。
java 线程池 创建方法
jmc_wax的博客
12-10 1801
java线程池的七个创建方法
连接池线程池配置——HttpClient连接池
01-19
### 配置 HttpClient 的连接池和线程池 #### PoolingClientConnectionManager 设置 为了高效利用 HTTP 请求资源，`PoolingClientConnectionManager` 是用于管理多个并发请求的关键组件。通过设置 `setMaxTotal` 和 `setDefaultMaxPerRoute` 参数可以控制整个连接池的最大连接数以及每条路由的最大连接数量。 ```java PoolingClientConnectionManager connectionManager = new PoolingClientConnectionManager(); connectionManager.setMaxTotal(200); // 整个连接池最大连接数 connectionManager.setDefaultMaxPerRoute(20); // 每个路由默认最大连接数 ``` 此配置有助于优化网络性能并减少延迟[^2]。 #### 创建 HttpClients 实例 由于 `HttpClient` 类本身是线程安全的，因此建议在整个应用程序生命周期内仅创建一个实例来处理所有的HTTP请求操作。 ```java CloseableHttpClient httpClient = HttpClients.custom() .setConnectionManager(connectionManager) .build(); ``` 这不仅提高了效率还减少了不必要的对象创建开销[^4]。 #### 结合线程池使用 当面对大量异步任务时，结合 Java 自带的 ExecutorService 来批量提交任务会更加合理有效。下面展示了一个简单的例子： ```java ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i < taskCount; ++i) { final int index = i; executorService.submit(() -> { try { CloseableHttpResponse response = httpClient.execute(new HttpGet("http://example.com")); System.out.println(index + ": " + response.getStatusLine()); EntityUtils.consume(response.getEntity()); } catch (IOException e) { Thread.currentThread().interrupt(); // Handle exception properly in production code. } }); } executorService.shutdown(); try { if (!executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS)) { throw new RuntimeException("Tasks did not complete."); } } catch (InterruptedException ie) { Thread.currentThread().interrupt(); } ``` 上述代码片段展示了如何在一个固定大小为10的工作线程池中执行一系列 GET 请求的任务。这种方式能够显著提升多IP查询场景下的整体响应速度，相比单一线程环境可缩短至六分之一的时间消耗[^3]。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值