Java线程池

最新推荐文章于 2024-06-20 20:46:49 发布

楠枬

最新推荐文章于 2024-06-20 20:46:49 发布

阅读量1.3k

点赞数 50

分类专栏： JavaEE 文章标签： java 开发语言线程池多线程

本文链接：https://blog.csdn.net/2301_76161469/article/details/135394426

版权

JavaEE 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

一、什么是线程池

线程池能够存储一定数量的线程，当我们需要时，就从池中取出使用，用完再还给线程池。

为什么要使用线程池？

线程池能够减少每次启动、销毁线程的损耗，同时，在执行任务时，不需要等待线程创建就可直接执行，提高了响应速度，此外，由线程池统一调度和分配线程，有利于线程的管理。

二、线程池的使用

ThreadPoolExecutor

在标准库中，线程池由 ThreadPoolExecutor 类实现，有 4 中构造方法：

    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;

        String name = Objects.toIdentityString(this);
        this.container = SharedThreadContainer.create(name);
    }

其中，

int corePoolSize：核心线程数。在默认情况下，核心线程会一直存活，但当将allowCoreThreadTimeout 设置为 true 时，核心线程超时后也会回收

int maximumPoolSize：最大线程数。线程池所能容纳的最大线程数。最大线程数 = 核心线程数 + 非核心线程数（即临时存在的线程，当不需要后会被回收）。

long keepAliveTime：保存存活时间。非核心线程闲置时开始计时，若超过改该时间，非核心线程被回收，若设置 allowCoreThreadTimeout 为true，则核心线程在超时后也会被回收

TimeUnit unit：keepAliveTime 的时间单位。例如：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）、TimeUnit.HOURS（小时）

BlockingQueue<Runnable> workQueue：任务队列。用于存储要执行的任务。通过 execute()方法将任务（Runnable对象）添加到队列（阻塞队列）中

ThreadFactory threadFactory：线程工厂。指定线程池创建新线程的方式RejectedExecutionHandler handler：拒绝策略。当达到最大线程数时线程池采取的策略

线程工厂

线程工厂用于指定创建线程的方式。ThreadFactory是一个接口类

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

其中只有一个newThread方法，用于接收一个Runnable对象，并将其封装到Thread对象中。

在自定义创建线程方式时，需要实现ThreadFactory接口，并实现new ThreadFactory方法。也可以使用默认的线程工厂 Executors.defaultThreadFactory

总而言之，其就是通过封装 new 操作，在方法内部设定不同的属性完成对象的初始化，构造对象的过程

拒绝策略

线程池提交一个任务时会先判断核心线程是否有空余，若没有，则将其添加到阻塞队列中。而当阻塞队列也满时，此时则会扩充线程池中线程数，直到到达最大线程数。而此时（即任务数 > 最大线程数 + 阻塞队列大小），提交的任务就会触发拒绝策略（即如何处理新提交的任务）

线程池提供了 4 种拒绝策略：

1. ThreadPoolExecutor.AbortPolicy：继续提交新任务，则抛出异常，中止任务

2. ThreadPoolExecutor.CallerRunsPolicy：提交的新任务，由添加任务的线程负责执行

3.ThreadPoolExecutor.DiscardOldestPolicy：丢弃最老的任务，执行新任务

4. ThreadPoolExecutor.DiscardPolicy：丢弃新任务

Executors

由于ThreadPoolExecutor的使用比较复杂，因此标准库中提供了 Executors 将ThreadPoolExecutors封装了一下（即在内部将ThreadPoolExecutors对象创建好并设置好不同的参数）

封装好的 4 种常见功能线程池：

1. FixedThreadPool：定长线程池

2. CachedThreadPool：可缓存线程池

3. SingleThreadExecutor：单线程化线程池

4.ScheduledThreadPool：定时线程池

如何选择使用ThreadPoolExecutor还是Executors?

根据需求进行选择。当希望高度定制化时，可选用ThreadPoolExecutor；当只是想简单使用线程池时，可选用Executors。

创建线程池时，如何设定线程池的线程数量？

不同的程序设定的线程池线程数量是不同的，因此，我们要根据具体情况具体分析

当一个进程中，所有线程都是cpu密集型（即这个线程大部分时间都要在cpu上运行），此时设定的线程数目就不应该超过cpu逻辑核心数

当一个进程中，所有线程都是IO密集型（即这个线程大部分时间都在等待IO，而不是在cpu上运行），此时的设定的线程数目就可以超过cpu逻辑核心数

然而，实际上在一个进程中大多数都是一部分线程是cpu密集型，一部分是IO密集型，它们的比例很难确定，因此，我们可以通过实验、测试的方式来找到合适的线程数量（即尝试设定不同的线程数量，分别进行性能测试，衡量不同线程数量的情况下，其时间开销、系统资源占用开销，从而找到合适的线程数量）

三、简单模拟实现线程池

在了解了什么是线程池和线程池的使用后，我们可以通过简单模拟实现线程池的方式来进一步理解线程池

在这里，我们模拟实现一个固定线程数量的线程池

思路分析

要实现一个线程池，我们首先要分析其应该具备哪些功能：

1. 创建一个阻塞队列，用于存放要执行的任务

2. 提供submit方法，用于添加新的任务

3. 提供构造方法，指定应该创建多少个线程

4. 在构造方法中，创建好这些线程

具体实现

我们首先创建出一个阻塞队列，用于存放要执行的任务

//用于存放任务的队列，且阻塞队列线程安全
private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(500);

然后实现submit方法，用来将任务添加到线程池中

   public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }

最后我们实现其构造方法，通过传入的参数n 指定创建线程数量为n的线程池，并在方法中让这些线程不断取出任务队列中的任务来执行

    public MyThreadPoolExecutor(int n){
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
                while (true){
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }

由于阻塞队列是线程安全的，因此能够保证其线程安全

关于阻塞队列，可参考：Java阻塞队列-CSDN博客

完整代码

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class MyThreadPoolExecutor {
    //用于存放任务的队列，且阻塞队列线程安全
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
    
    public MyThreadPoolExecutor(int n){
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
                while (true){
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }
    
    //添加任务
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
}

我们可以简单地测试所编写的代码是否正确：

class Demo{
    public static void main(String[] args) throws InterruptedException {
        MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor(5);
        for (int i = 0; i < 100; i++) {
            int n = i;
            myThreadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("当前线程：" + Thread.currentThread().getName() + "执行任务：" + n);
                }
            });
        }
    }
}

运行结果：

为什么会出现上述结果？

这是由于多个线程之间的执行顺序是不确定的，当某个线程取到任务后，并非立即执行，在此过程中另一个线程就可能插到其前面了。

楠枬

关注

50
点赞
踩
56

收藏

觉得还不错? 一键收藏
打赏
22
评论
Java线程池

线程池能够存储一定数量的线程，当我们需要时，就从池中取出使用，用完再还给线程池。为什么要使用线程池？线程池能够减少每次启动、销毁线程的损耗，同时，在执行任务时，不需要等待线程创建就可直接执行，提高了响应速度，此外，由线程池统一调度和分配线程，有利于线程的管理。
复制链接

扫一扫