关于线程池

最新推荐文章于 2024-11-03 11:01:20 发布

Coisíní3333

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量68

点赞数 1

分类专栏： Java_ee 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_59561046/article/details/130858332

版权

Java_ee 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

线程池通过减少线程的创建和销毁开销来提高效率。Executors提供了多种线程池创建方式，如newSingleThreadExecutor、newFixedThreadPool和newCachedThreadPool。线程池的七大参数包括核心线程数、最大线程数、存活时间、超时单位、工作队列、线程工厂和拒绝策略。工作流程涉及核心线程、任务队列和拒绝策略的管理。

摘要由CSDN通过智能技术生成

3.使用Executors 创建常见的线程池

线程池是什么

想象这么一个场景：在学校附近新开了一家快递店，老板很精明，想到一个与众不同的办法来经营。店里没有雇人，而是每次有业务来了，就现场找一名同学过来把快递送了，然后解雇同学。这个类比我们平时来一个任务，起一个线程进行处理的模式。很快老板发现问题来了，每次招聘 + 解雇同学的成本还是非常高的。老板还是很善于变通的，知道了为什么大家都要雇人了，所以指定了一个指标，公司业务人员会扩张到 3 个人，但还是随着业务逐步雇人。于是再有业务来了，老板就看，如果现在公司还没 3 个人，就雇一个人去送快递，否则只是把业务放到一个本本上，等着 3 个快递人员空闲的时候去处理。这个就是我们要带出的线程池的模式。

线程池最大的好处就是减少每次启动、销毁线程的损耗。

1.线程池的参数介绍

1.1创建线程池的方式

方式	描述
Executors.newSingleThreadExecutor();	创建一个单一的线程池
Executors.newFixedThreadPool(int nThreads);	创建一个固定大小的线程池，参数填线程池大小
Executors.newCachedThreadPool();	创建一个可伸缩的线程池，遇强则强，遇弱则弱


public class ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor(); 
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);
        //ExecutorService threadPool = Executors.newCachedThreadPool();
        try {
            for (int i = 1; i <= 10; i++) {
                //在execute中丢入一个Runnable --->  lambda 表达式
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //使用完毕后，程序结束，关闭线程池
            threadPool.shutdown();
        }
    }

1.2线程池的七大参数

参数	描述
int corePoolSize	核心线程数大小
int maximumPoolSize	最核心线程池大小
long keepAliveTime	超时使用没有人使用会自动释放
TimeUnit unit	超时单位
BlockingQueue<Runnable>workQueue	阻塞队列
ThreadFactory threadFactory	线程工厂，创建线程的，一般不用动
RejecteExecutionHandler handler	拒绝策略

在上面线程池的三种创建方式种中，点进源码，可以看到它们都new 了一个 ThreadPoolExecutor

//newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1, //核心线程，最大线程为 1
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
//newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads, //核心线程，最大线程为传进来的参数
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
//newCachedThreadPool
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,//核心线程默认是0，最大线程为21亿
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

ThreadPoolExecutor 中就包含了线程池的七大参数


// ThreadPoolExecutor
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;
    }

2.线程池的工作流程

执行任务，核心线程数未达到corePoolSize该值，就创建线程。否则塞入任务队列。

任务队列满了，就创建线程，但是总线程数不能超过该值maximumPoolSize。

如果任务队列满了，线程数达到maximumPoolSize值，则执行拒绝策略。

工作线程则不停的轮询去队列中poll任务，如果poll为空，则工作线程执行结束(回收线程)。

如果工作线程数<=核心线程数corePoolSize，则使用take从队列中获取任务(核心线程一直await)。

3.使用Executors 创建常见的线程池

Executors 创建线程池的几种方式

newCachedThreadPool: 创建线程数目动态增长的线程池.

newFixedThreadPool: 创建固定线程数的线程池

newSingleThreadExecutor: 创建只包含单个线程的线程池.

newScheduledThreadPool: 设定延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.

public class Demo01_ThreadPool {
    public static void main(String[] args) {
        // 1. 用来处理大量短时间工作任务的线程池,如果池中没有可用的线程将创建新的线程，如果线程空闲60秒将收回并移出缓存
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        // 2. 创建一个操作无界队列且固定大小线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        // 3. 创建一个操作无界队列且只有一个工作线程的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        // 4. 创建一个单线程执行器，可以在给定时间后执行或定期执行。
        ScheduledExecutorService singleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
        // 5. 创建一个指定大小的线程池，可以在给定时间后执行或定期执行。
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        // 6. 创建一个指定大小（不传入参数，为当前机器CPU核心数）的线程池，并行地处理任务，不保证处理顺序
        Executors.newWorkStealingPool();
    }
}