神奇的线程池——妈妈再也不用担心线程的创建销毁太花时间啦

线程池是Java中用于高效管理线程的容器,避免频繁创建和销毁线程带来的开销。常见线程池包括可缓存线程池、定长线程池、周期定长线程池和单线程线程池。ThreadPoolExecutor是线程池的实现类,其构造参数如corePoolSize、maximumPoolSize等决定了线程池的行为。线程池通过工作队列和饱和策略来处理任务,提供灵活性和性能优化。

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

线程池

什么是线程池

线程池(ThreadPool),听起来就非常的有意思哈。乍一看还以为是将线程放在一个池子中,其实啊,还真是这样,也可以简单的理解为一个可以容纳多个线程的容器。
那么,线程池有啥用呢,和线程相比又有什么特别点呢

线程池的的优势

Java中使用线程的话,除了处理用户的请求之外,时间花的最多的地方就在于创建和销毁线程。而对于线程来说,这两个操作又是必须要做的,而用线程池来代替的话,将线程用线程池来储存着,用到的时候既不用进行创建线程,也不用在结束使用后进行销毁,大大地提高了时间效率。
而且另一方面来说,线程中的切换也是一个需要消耗系统资源的地方,用线程池能很好的解决资源不足问题

线程池的分类

常用线程池主要有以下四种类型:
可缓存线程池(CachedThreadPool):也叫作不定长的线程池,主要优势在于灵活,无论多少线程并发也能承载
定长线程池(FixedThreadPool):优势在于能控制最大的线程并发数量,接下来进入的线程都只能排队等候
周期定长线程池(ScheduledThreadPool):与定长线程池类似,但可以以给定时间为周期执行任务
单线程线程池(SingleThreadPool):同一时间只能容纳一个线程进行任务,后续线程将会进行排队等候

线程池的实现

1、缓存线程池的使用案例:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();
        es.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行该代码");
            }
        });
    }
}

2、定长线程池的使用案例:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool();
        es.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行该代码");
            }
        });
    }
}

3、单线程线程池使用案例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService es = Executors.newSingleThreadExecutor();
        es.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行该代码");
            }
        });
    }
}

4、周期定长线程池使用案例:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService es = Executors.newScheduledThreadPool(2);
        es.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行该代码");
            }
        },5, ,1,TimeUnit.SECONDS);
    }
}
ThreadPoolExecutor

其实,以上四种线程池只是用得较多的几种,被封装好了的线程池,除此之外,也要对线程池的真正实现类ThreadPoolExecutor有所了解。
首先,看一下构造方法:

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

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

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

可以看到,该类有四个构造方法,并且其中还有一些参数:
corePoolSize:核心线程数,核心线程指的是即使线程处于空闲状态也不会被回收掉,如:缓存线程池中核心线程池就是0,因为缓存线程池中线程数是不定的,而单线程线程池由于有且只有一个线程,其中核心线程数就是1,其他两个则是参数相关。当变量allowCoreThreadTimeout设置为true时,核心线程也会被回收
maximumPoolSize:线程池最大线程数,当创建线程超过最大线程数时,将会执行饱和策略。
keepAliveTime:线程闲置时长,当非核心线程闲置时间超过时长时,将会被回收。
unit:线程闲置时长的单位。
workQueue:任务队列,往线程池中添加的任务将储存在该队列中
threadFactory:线程工厂,创建新线程时的统一格式。
handler:饱和策略:当线程达到最大线程数时所进行的处理,有以下4种常用的策略:
AbortPolicy(默认策略):丢弃任务并抛出异常;
CallerRunsPolicy:调用线程处理该任务
DiscardPolicy:丢弃任务但不抛出异常,可根据此策略进行扩展自定义策略
DiscardOldestPolicy:丢弃队列中最早的未处理的任务,将新任务执行
除了构造方法,它还有一些常用的普通方法:

public void execute​(Runnable command)

该方法给定一个任务,线程池对该任务执行或进行相应的处理

public void shutdown()

启动关闭线程池,已启动的任务将会继续完成,但不接收新的任务
接下来,我们就可以理解四个封装线程池的源码了:
缓存线程池是一个核心线程数为0,最大线程数为整型最大值,且闲置时长 偏长的线程池:

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

定长线程池是一个核心线程数为参数,最大线程数与核心线程数一致,且每个线程无闲置时长的线程池

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

单线程线程池是一个核心线程数及最大线程数都为1的线程池

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

周期定长线程池较为特殊,核心线程数为参数,最大线程数为整型最大值,除了闲置时间之外,他的任务队列是以延时队列进行储存的,时间没到无法提取任务

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值