java线程池

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

#java #线程池 #线程

本文详细介绍了Java线程池的基本概念、使用方法及其内部实现原理。涵盖了常用的线程池创建方式，如newCachedThreadPool、newSingleThreadExecutor等，并探讨了自定义线程池的实现细节。

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

线程池

线程池的好处：

重用存在的线程，减少对象创建、消亡的开销。
有效控制最大并发数，提高系统资源使用率。
定时执行、定期执行。

线程池所在的包为java.util.concurrent
顶级接口为Executor，真正的线程池接口是ExecutorService
Executors类提供农创建线程池的方法

newCachedThreadPool() 创建一个可缓存的线程池，有任务是时才创建新线程
newSingleThreadExecutor() 创建一个单线程池
newFixedThreadPool() 创建有个固定长度的线程池，空闲线程会一直保留
newSecheduledThreadPool() 创建一个固定长度的的线程池，以延迟或固定的时间执行任务

使用newCachedThreadPool()创建线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
 * 使用newCachedThreadPool()创建线程池
 */
public class ThreadCurrent {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        //让线程池去执行10个任务
        /*
         * 10个任务被线程池中的一个任务执行
         * 大大减少了线程的销和创建时间。更节省效率。
         * 当休眠省了以后，会有更多线程进来执行。
         * 当线程池中的线程执行完当前任务之后不是销毁而是去执行新的任务。增加了灵活性。
         */

        for (int i = 0; i < 10; i++) {
            pool.execute(new MyRunning(i));
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
class MyRunning implements  Runnable{
    int num;

    public MyRunning(int num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"  "+num);
    }

}

这里写图片描述

让线程池中的一个线程去执行10次任务，减少了线程创建和销毁的时间。提高了程序效率。

使用newSingleThreadExecutor()创建线程

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        /*
         * 单线程池。线程池中只有一个线程执行
         * 当一个线程正在执行时，其他线程会等待当前线程执行完毕再执行
         */
        for (int i = 0; i < 10; i++) {
            singleThreadExecutor.execute(new MyRunning(i));
        }
    }
}
class MyRunning implements  Runnable{
    int num;

    public MyRunning(int num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"  "+num);
    }
}

这里写图片描述

单线程池，线程池中只存在一个线程。让这1个线程执行任务。与CachedPool相似。

使用fixedThreadPool创建线程

/*
 * 使用FixedThreadPool创建线程池
 */
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        /*
         * 最多只能是指定线程范围内的线程数
         * 
         */
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new MyRunning(i));
        }
    }
}
class MyRunning implements  Runnable{
    int num;

    public MyRunning(int num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"  "+num);
    }
}

这里写图片描述

线程池中的线程随机来执行给定的任务。线程中的最大线程数量自己指定。

使用ScheduledThredPool创建线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/*
 * 使用ScheduledThreadPool创建线程池
 */
public class ThreadPool {
    public static void main(String[] args) {
        /*
         * ScheduledThreadPool创建线程池
         * 具有延迟执行和周期执行的功能
         * ScheduledThreadPool的scheduleAtFixedRate()方法：
         *      该方法有四个参数：1.要执行的任务执行Running接口的线程类
         *                   2.首次执行的延迟时间
         *                   3.连续执行之间的周期
         *                   4.2、3参数的时间单位，枚举类型(DAYS/HOURS/SECONDS/MICROSECONDS/MINUTES)
         */
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("************线程开始执行*******");
        //每个任务执行前有1秒钟的延迟。每2秒执行一次该任务
        scheduledThreadPool.scheduleAtFixedRate(new MyRunning(),5, 2, TimeUnit.SECONDS);
    }
}
class MyRunning implements  Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" 延时5秒钟执行、每两秒钟执行一次 ");
    }
}

这里写图片描述

ScheduledThredPool具有延迟执行和线程周期执行的功能。

自定义线程池

当Excetors接口创建的线程池不足以满足需求时我们可以自己创建线程池类

利用ThreadPoolExecutor类

public class MyThreadPool {
    public static void main(String[] args) {
        //创建一个自定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 7, 300,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(4));
        for(int i=1;i<=12;i++){
            executor.execute(new MyRunning(i));
            System.out.println("线程池中的线程数："+executor.getPoolSize()
                                +"。等待执行的任务数："+executor.getQueue().size()
                                +"。已经执行完的任务数："+executor.getCompletedTaskCount());
        }
        //关闭线程池
        executor.shutdown();
    }
}

class MyRunning implements Runnable {
    int num; // 第几个任务

    public MyRunning(int num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        System.out.println("正在执行" + num);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(num + "执行完毕");
    }

}


原理：

假设核心线程有5个、最大线程数有7个、最大队列数有4个、任务有12个
当核心线程装满5个后，会在队列装任务4个，队列中的线程处于等待状态。
当队列也满的时候，会遵循最大线程数来继续创建2个线程。
这时还有最后一个任务，但是这时没有多余的线程或者队列来执行任务， 那么就会遵循拒绝任务的策略来拒绝此任务，此任务被销毁。抛出异常。
当线程池中的全部任务都执行完毕时，依次从队列中接受任务新建线程继续执行任务。 当所有队列所有线程池中的任务都执行完毕后，会保留核心线程数5个， 其余线程会销毁。核心线程即使没有任务也会被保留下来。

来重点看自定义线程

java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。

在ThreadPoolExecutor类中提供了四个构造方法：

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

从上面的代码可以得知，ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，事实上，通过观察每个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工作。

看看构造器中的参数

ThreadPoolExecutor构造中有跟多参数来规定自己的线程池所具有的功能
corePoolSize：核心池的大小。开始执行时的线城池的大
maximumPoolSize：线程池的最大线程数
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止
unit：参数keepAliveTime的时间单位
workQueue：一个阻塞队列，用来存储等待执行的任务
threadFactory：线程工厂，主要用来创建线程
handler：表示当拒绝处理任务时的策略

unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性。

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

workQueue：这里的阻塞队列有以下几种选择：

ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

在ThreadPoolExecutor类中有几个非常重要的方法：

execute()   向线程池提交一个任务，交由线程池去执行。
submit()    与execute()相同，能返回任务执行的结果。
shutdown()      不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止按照提交顺序有序的关闭，不接受新任务。
shutdownNow()   立即停止所有的活动，包括暂停和等待活动。并返回等待任务列表
getOueue()      获取等待的任务队列
getPoolSize()   获取当前线程池中的线程数
getActiveCount()    获取执行任务的线程数
getCompletedTaskCount() 获取已完成的任务数

深入剖析线程池的实现原理

1.线程池的状态：
在ThreadPoolExecutor中定义了一个volatile变量，另外定义了几个static final变量表示线程池的各个状态：

volatile int runState;     //表示当前线程池的状态
static final int RUNNING    = 0;
static final int SHUTDOWN   = 1;
static final int STOP       = 2;
static final int TERMINATED = 3;

runState表示当前线程池的状态，它是一个volatile变量用来保证线程之间的可见性；
下面的几个static final变量表示runState可能的几个取值。
当创建线程池后，初始时，线程池处于RUNNING状态；

当创建线程池后，初始时，线程池处于RUNNING状态；
如果调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；
如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；
当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

2.任务的执行
在了解将任务提交给线程池到任务执行完毕整个过程之前，我们先来看一下ThreadPoolExecutor类中其他的一些比较重要成员变量：

private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务
private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小runState等）的改变都要使用这个锁
private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工作集
private volatile long  keepAliveTime;    //线程存货时间   
private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间
private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数
private volatile int   poolSize;       //线程池中当前的线程数
private volatile RejectedExecutionHandler handler; //任务拒绝策略
private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程
private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数
private long completedTaskCount;   //用来记录已经执行完毕的任务个数

3.任务缓存队列及排队策略

ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；
LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

4.任务拒绝策略
当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：

ThreadPoolExecutor.AbortPolicy:丢弃任务并
RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

5.线程池的关闭

shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务。
shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务。

6.线程池容量的动态调整

ThreadPoolExecutor提供了动态调整线程池容量大小的方法：

setCorePoolSize()和setMaximumPoolSize()，
setCorePoolSize：设置核心池大小
setMaximumPoolSize：设置线程池最大能创建的线程数目大小

当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还可能立即创建新的线程来执行任务。

并发线程编程：
参考：
http://ifeve.com/java-threadpool/

Java线程池ThreadPoolExecutor背后的秘密与实践
张彦峰的博客
05-12 170万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
java线程池使用后到底要关闭吗
08-26
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...
Java 线程池
05-01
NULL 博文链接：https://yangeoo.iteye.com/blog/2249853
java的线程池
qq_51476492的博客
06-16 683
例如，自定义一个线程池，核心线程有3个，临时线程有3个，阻塞队列长度为3。当有8个任务提交时，线程池现创建3个线程执行前3个任务，第4，5，6个任务阻塞队列中排队等待，线程池再创建2个临时线程取处理任务7和任务8。当有10个任务提交时，线程池现创建3个线程执行前3个任务，第4，5，6个任务阻塞队列中排队等待，线程池再创建3个临时线程取处理任务7、8、9，任务10会触发任务拒绝策略。核心线程数量，线程池中最大线程数量、空闲时间（值）、空闲时间（单位）、阻塞队列、创建线程的方式、要执行的任务过多时的解决方案。
java线程池详解
最新发布
xrkhy的博客
06-21 1713
先看我们遇到的问题：我们创建线程的方式很简单， new Thread(() -> {…}) ，就是因为这么简单粗暴的方式，才带来了致命的问题。首先线程的创建和销毁都是很耗时很浪费性能的操作，你用线程为了什么？为了就是异步，为了就是提升性能。简单的new三五个Thread还好，我需要一千个线程呢？你也for循环new1000个Thread吗？用完在销毁掉。那这一千个线程的创建和销毁的性能是很糟糕的！RUNNING ：接受新任务并处理排队任务。SHUTDOWN ：不接受新任务，但是会处理排队任务。
Java的线程池
我能在河边钓一整天的鱼
04-02 271
目录 线程池的概念 线程池的使用 线程池的概念 其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作。在JDK1.5之后，内置了线程池，我们不需要再手动创建线程池了 线程池的优点 1.降低资源消耗 2.提高响应速度 3.提高线程的可管理性 线程池的使用 1.使用线程池的工厂类Executors里面提供的...
Java-线程池
一蓑烟雨任平生
06-10 438
线程池 1、线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。（是什么） 2、那么，我们为什么需要用到线程池呢？每次用的时候手动创建不行吗？ 在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统
java线程池实现批量下载文件
08-25
Java线程池实现批量下载文件 Java线程池实现批量下载文件是指使用Java语言和线程池机制来实现批量下载文件的功能。这种方法可以大幅提高下载速度和效率，特别是当需要下载大量文件时。下面将对Java线程池实现批量...
java线程池源码-cThreadPool:JAVA线程池源码分析与重写
05-25
java线程池源码 cThreadPool 项目描述：对java.util.concurrent包下线程池相关源码进行重新实现，深入研究和学习线程池超时机制、饱和策略、生命周期等知识 ThreadPoolExecutor类下部分方法和内部类介绍： 1、Worker...
java线程池处理多并发，所有进程执行完后再统一处理结果
01-21
java线程池处理多并发，所有进程执行完后再统一处理结果线程池配置类多线程并行demo 线程池配置类 import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation....
多线程（五） 线程池
qq_35670694的博客
04-20 207
线程池方式 线程池的思想 我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？ 在Java中可以通过线程池来达到这样的效果...
java 线程池
weixin_44052919的博客
08-27 155
线程池 线程池的优势 （1）、降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗； （2）、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行； （3）方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生内存溢出，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。 （4）提供更强大的功能，延时定时线程池。 1. 线程池的概念： 线程池就是首先创建一些线程，它们的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值