Java线程池详解与使用指南

最新推荐文章于 2024-08-04 08:00:00 发布
最新推荐文章于 2024-08-04 08:00:00 发布
阅读量1.1k 收藏 20
点赞数 15
分类专栏： # Java学习-基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jz_Stu/article/details/137129487
版权

Java线程池详解与使用指南

文章目录

一、线程池概述

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的ThreadFactory创建一个新线程。线程池能够复用线程，减少线程创建和销毁的开销，从而提高系统的响应速度和吞吐量。

二、Java中的线程池类型

1、FixedThreadPool：固定大小的线程池。

它的核心线程数和最大线程数都是创建线程池时指定的值，即使空闲，也不会被销毁。如果当前线程数超过核心线程数，那么空闲线程等待新任务的最长时间为keepAliveTime。适合执行长期的任务。

示例：

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class FixedThreadPoolExample {  
    public static void main(String[] args) {  
        // 创建一个固定大小为3的线程池  
        ExecutorService executor = Executors.newFixedThreadPool(3);  
          
        // 提交任务到线程池  
        for (int i = 0; i < 5; i++) {  
            final int taskId = i;  
            executor.submit(() -> {  
                System.out.println("Executing task " + taskId + " on thread " + Thread.currentThread().getName());  
            });  
        }  
          
        // 关闭线程池  
        executor.shutdown();  
        while (!executor.isTerminated()) {  
            // 等待所有任务执行完毕  
        }  
        System.out.println("All tasks are completed.");  
    }  
}

2、CachedThreadPool：可缓存的线程池。

它的核心线程数为0，最大线程数为Integer.MAX_VALUE，即可以创建任意多的线程。当线程数超过核心线程数时，空闲线程等待新任务的最长时间为60秒，超过这个时间后，多余空闲线程将被终止。这种线程池适合执行大量短期的异步任务。

示例：

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class CachedThreadPoolExample {  
    public static void main(String[] args) {  
        // 创建一个可缓存的线程池  
        ExecutorService executor = Executors.newCachedThreadPool();  
          
        // 提交任务到线程池  
        for (int i = 0; i < 10; i++) {  
            final int taskId = i;  
            executor.submit(() -> {  
                System.out.println("Executing task " + taskId + " on thread " + Thread.currentThread().getName());  
            });  
        }  
          
        // 关闭线程池  
        executor.shutdown();  
        while (!executor.isTerminated()) {  
            // 等待所有任务执行完毕  
        }  
        System.out.println("All tasks are completed.");  
    }  
}

3、ScheduledThreadPool：支持定时及周期性任务执行的线程池。

示例：

import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
  
public class ScheduledThreadPoolExample {  
    public static void main(String[] args) {  
        // 创建一个支持定时任务的线程池  
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);  
          
        // 安排任务在1秒后执行  
        executor.schedule(() -> {  
            System.out.println("Scheduled task executed.");  
        }, 1, TimeUnit.SECONDS);  
          
        // 关闭线程池  
        executor.shutdown();  
        try {  
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {  
                executor.shutdownNow();  
            }  
        } catch (InterruptedException e) {  
            executor.shutdownNow();  
            Thread.currentThread().interrupt();  
        }  
    }  
}

4、SingleThreadExecutor：单线程化的线程池。

它只用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO, LIFO, 优先级）执行。

示例：

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class SingleThreadExecutorExample {  
    public static void main(String[] args) {  
        // 创建一个单线程化的线程池  
        ExecutorService executor = Executors.newSingleThreadExecutor();  
          
        // 提交任务到线程池  
        for (int i = 0; i < 5; i++) {  
            final int taskId = i;  
            executor.submit(() -> {  
                System.out.println("Executing task " + taskId + " on thread " + Thread.currentThread().getName());  
            });  
        }  
          
        // 关闭线程池  
        executor.shutdown();  
        while (!executor.isTerminated()) {  
            // 等待线程执行完成
        }

5、WorkStealingPool (Java 8及以上)

WorkStealingPool是Java 8引入的一种线程池，它利用“工作窃取”算法来提高多线程间的任务执行效率。在这种线程池中，当某个线程的任务队列为空时，它可以尝试从其他线程的任务队列中“窃取”任务来执行。这有助于减少线程间的任务不平衡，并提高整体的吞吐量。

示例：

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class WorkStealingPoolExample {  
    public static void main(String[] args) {  
        // 创建一个具有默认并行级别的 WorkStealingPool  
        ExecutorService executor = Executors.newWorkStealingPool();  
  
        // 提交任务到线程池  
        for (int i = 0; i < 10; i++) {  
            final int taskId = i;  
            executor.submit(() -> {  
                System.out.println("Executing task " + taskId + " on thread " + Thread.currentThread().getName());  
            });  
        }  
  
        // 关闭线程池  
        executor.shutdown();  
        // 注意：这里使用了try-catch来确保在主线程中可以中断等待  
        try {  
            if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {  
                executor.shutdownNow();  
            }  
        } catch (InterruptedException e) {  
            executor.shutdownNow();  
            Thread.currentThread().interrupt();  
        }  
    }  
}

6、Custom ThreadPoolExecutor（项目中还是比较常用的）

除了上述提供的便捷创建方法外，Java还提供了ThreadPoolExecutor类，它允许你定制线程池的各个参数，包括核心线程数、最大线程数、队列类型、拒绝策略等。通过定制ThreadPoolExecutor，你可以实现更为灵活的线程池策略。

import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  
  
public class CustomThreadPoolExample {  
    public static void main(String[] args) {  
        // 线程池的核心线程数  
        int corePoolSize = 3;  
        // 线程池的最大线程数  
        int maximumPoolSize = 5;  
        // 线程池的队列长度  
        int queueCapacity = 10;  
        // 创建一个线程池，并自定义各个参数  
        ThreadPoolExecutor executor = new ThreadPoolExecutor(  
                corePoolSize, // 核心线程数  
                maximumPoolSize, // 最大线程数  
                60L, // 空闲线程等待任务的最长时间  
                TimeUnit.SECONDS, // 空闲线程等待任务的时间单位  
                new ArrayBlockingQueue<>(queueCapacity), // 任务队列  
                new ThreadPoolExecutor.DiscardPolicy() // 拒绝策略  
        );  
  
        // 提交任务到线程池  
        for (int i = 0; i < 15; i++) {  
            final int taskId = i;  
            executor.submit(() -> {  
                System.out.println("Executing task " + taskId + " on thread " + Thread.currentThread().getName());  
            });  
        }  
  
        // 关闭线程池  
        executor.shutdown();  
        while (!executor.isTerminated()) {  
            // 等待所有任务执行完毕  
        }  
        System.out.println("All tasks are completed.");  
    }  
}

在这个例子中，我们创建了一个具有3个核心线程和5个最大线程的ThreadPoolExecutor，它使用一个容量为10的ArrayBlockingQueue来存储任务，当队列满时会在核心线程的基础上创建线程。我们还设置了一个拒绝策略为DiscardPolicy，这意味着当队列满并且没有可用线程时，新提交的任务将被丢弃。你可以根据需要调整这些参数，并选择其他队列类型或拒绝策略。

三、线程池的创建与配置

创建线程池时，通常需要配置以下参数：

  1. corePoolSize：核心线程数，即线程池中的常驻线程数。
  2. maximumPoolSize：线程池允许的最大线程数。
  3. keepAliveTime：当线程数超过核心线程数时，空闲线程等待新任务的最长时间。
  4. TimeUnit：keepAliveTime的时间单位。
  5. BlockingQueue：用于存储待执行任务的阻塞队列。
  6. ThreadFactory：用于创建新线程的线程工厂。
  7. RejectedExecutionHandler：当线程池无法处理新任务时的拒绝策略。

具体的使用配置可以看Custom ThreadPoolExecutor中的自定义线程。

四、线程池推荐

  1. 需要执行大量短期异步任务的应用，推荐使用CachedThreadPool，它能够根据任务数量动态调整线程数，提高系统响应速度。
  2. 需要执行长期任务的应用，推荐使用FixedThreadPool，它固定线程数，可以避免线程频繁创建和销毁的开销。
  3. 需要执行定时或周期性任务的应用，推荐使用ScheduledThreadPool，它支持定时和周期性任务的执行。

总结

线程池是Java中高效管理线程资源的重要工具，通过合理使用线程池，我们可以提高系统的并发处理能力和性能。在选择线程池类型时，需要根据应用的具体需求来决定。同时，合理配置线程池的参数也是非常重要的。希望本文能够帮助需要的人。

Jz_Stu
关注
专栏目录
线程池的4种创建方式
qq_35657661的博客
12-20 975
线程池四种创建方式 Java通过Executors（jdk1.5并发包）提供四种线程池，分别为： newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线...
一文带你了解Java线程池(Executor)-上
m0_68103752的博客
04-06 1649
分析Java线程池就离不开Executor类，今天就让我们来一起好好看下 Executor框架 为了更好地控制多线程，JDK提供了一套Executor框架，可以有效地进行线程控制，其本质上就是一个线程池。 其中ThreadPoolExecutor表示一个线程池。Executors类则扮演着线程池工厂的角色，通过Executors可以取得一个拥有特定功能的线程池。从上图可知，ThreadPoolExecutor类实现了Executor接口，因此，通过这个接口，任何Runnable对象都可以被Th
Java线程池使用说明
明明
02-20 805
一 简介 线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。 二：线程池 线程池的作用： 线程池作用就是限制系统中执行线程的数量
Java中的5种线程池类型
最新发布
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
08-04 4337
线程池是一个重要的概念，它允许开发者通过复用已有的线程来异步地执行任务，从而有效地减少线程的创建和销毁的开销，提高程序的性能。
java中线程池的使用方法
weixin_30387423的博客
09-04 85
1 引入线程池的原因 　　由于线程的生命周期中包括创建、就绪、运行、阻塞、销毁阶段，当我们待处理的任务数目较小时，我们可以自己创建几个线程来处理相应的任务，但当有大量的任务时，由于创建、销毁线程需要很大的开销，运用线程池这些问题就大大的缓解了。 2 线程池的使用 　　我们只需要运用Executors类给我们提供的静态方法，就可以创建相应的线程池： 　　public static Execu...
java中线程池的使用
diaojin6880的博客
09-21 94
public static ExecutorSevice newSingleThreadExecutor() public static ExecutorSevice newFixedThreadPool() public static ExecutorSevice newCachedThreadPool() public static Sched...
java线程池的使用
weixin_41979002的博客
07-30 1638
本文转载于以下文章，原文链接如下： https://www.cnblogs.com/ljp-sun/p/6580147.html https://blog.csdn.net/yinni11/article/details/79917640 前言 为什么需要线程池？ 多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。 假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。 如果：T1 + T3
内存泄漏防护：Java线程池与诊断技术的深入指南
[内存泄漏防护：Java线程池与诊断技术的深入指南](https://www.atatus.com/blog/content/images/size/w960/2023/09/java-performance-optimization.png) # 1. Java线程池基础概述 线程池是管理线程生命周期的一种...
java 多线程编程实战指南（核心 + 设计模式 完整版）
03-20
《Java多线程编程实战指南》这本书深入浅出地讲解了Java多线程的核心概念和实战技巧，分为核心篇和设计模式篇，旨在帮助开发者掌握并应用多线程技术。 1. **线程基础** - **线程的创建**：Java提供了两种创建线程...
Tomcat与Java Web开发技术详解（第2版）.pdf
02-11
《Tomcat与Java Web开发技术详解（第2版）》是一本深入探讨Java Web应用程序部署和运行环境的权威指南。本书主要围绕Apache Tomcat服务器展开，涵盖了从基础概念到高级特性的全方位讲解，旨在帮助读者掌握Java Web...
【Java面试+Java学习指南】一部分大部分Java招聘所需要掌握的核心知识
10-23
Java必会基础与新版本特性 线上问题排查 集合框架 哈希映射 并发哈希映射 数组列表 向量 深入浅出JVM JVM内存模型 性能调优、线上问题排查 类加载机制详解 垃圾回收机制 垃圾回收器、垃圾回收算法 ARM与多线程 ...
Java线程池的使用
daijianzhou的专栏
03-25 1447
Java线程池的使用 线程池就是放了线程的池子，它可以对池子里面的线程进行维护，有效避免了重复创建线程和销毁线程所耗费的时间 线程的七大参数 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit u
java线程池应用
mayufenga1的博客
11-06 80
碰到一个线程池的问题还真的做不出来，网上查啦下，原来java1.5中增加啦java线程池的实现。 一、简介 线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为： ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit ...
java多线程详解(7)-线程池的使用
weixin_30687811的博客
09-16 247
在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了， 这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 这个是时候我们需要使用线程池技术创建多线程。 本文目录大纲： 一.Java中的ThreadPoolExecutor类 二.深入剖析线程池实现...
Java几种线程池类型介绍及使用
热门推荐
小小本科生成长之路
10-29 1万+
一、线程池使用场景 单个任务处理时间短 将需处理的任务数量大 二、使用Java线程池好处1.使用new Thread()创建线程的弊端： 每次通过new Thread()创建对象性能不佳。 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 缺乏更多功能，如定时执行、定期执行、线程中断。 2.使用Java线程池的好处： 重用存在的线程，减少对象创建、消亡的开
Java线程池使用
Jbase的博客
05-13 3088
我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 　　如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 　　那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？ 　　在Java中可以通过线程池来达到这样的效果。今天我们就...
Java中线程池的使用
Guan_Java的博客
11-25 239
一、线程池的作用 线程池的作用就是限制系统中执行线程的数量。 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果； 少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量， 其他线程排队等候。一个任务执行完毕，再从队列中取最前面的任务开始执行。 若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时， 如果线程池中有等待的工作线程，就可以开始运行了；否则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jz_Stu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值