线程池的使用

Posted 2023-04-04 小尹编码中...

Java语言虽然内置了多线程支持，启动一个新线程非常方便，但是，创建线程需要操作系统资源（线程资源，栈空间等），频繁创建和销毁大量线程需要消耗大量时间

如果复用一组线程，流程图如下：

把很多的小任务让一组线程来执行，而不是每个小任务对应一个新线程

这种能接收大量小任务并进行分发处理的就是线程池

假设没有线程池引发的后果：

1. 创建线程所需要的时间多少？以及线程在完成工作之后会被丢弃的事实
2. 如果允许所有的并发请求都通过新线程来处理，那么我们没法限制系统内的并发执行线程的数量
3. 无限制的线程可能耗尽系统资源 （如CPU时间和内存）

线程池的主要思想：

• 在进程开始时，创建一定数量的线程，并放到线程池中等待工作
• 当服务器收到请求时，线程池会唤醒池内的一个线程（如果有可用线程），并将需要服务的请求传递给它
• 线程完成了服务，会返回线程池中等待工作
• 如果线程池中没有可用线程，那么服务器会等待，直到有可用线程为止

总结：

线程池内部维护了若干个线程，没有任务的时候，这些线程都处于等待状态

如果有新任务，就分配一个空闲线程执行。如果所有线程都处于忙碌状态，新任务要么放入队列等待，要么增加一个新线程进行处理

线程池的优点：

1. 用已有的线程服务请求比创建一个线程更快
2. 线程池限制了任何时候可用线程的数量，对不能支持大量并发线程的系统很重要
3. 将要执行任务从创建任务的机制中分离出来（例如，任务可以被安排在某一个时间延迟后再执行，或定期执行）

线程池内线程的数量可以通过一些因素来估算（例如，系统CPU的数量，物理内存的大小，并发客户请求数量的期望值等）

更高级的线程池架构可以根据使用模式动态调整线程池内线程的数量，这类线程池架构再系统负荷低的时候，提供比较小的线程池，从而降低内存消耗（例如Apple的大中央空调）

Java标准库提供了 ExecutorService 接口表示线程池，用法如下：

            Runnable task1 = null;
            Runnable task2 = null;
            Runnable task3 = null;
            Runnable task4 = null;
            Runnable task5 = null;
            //创建固定大小的线程池
            ExecutorService executorService=Executors.newFixedThreadPool(3);
            //提交任务
            executorService.submit(task1);
            executorService.submit(task2);
            executorService.submit(task3);
            executorService.submit(task4);
            executorService.submit(task5);

ExecutorService 只是接口，Java标准库提供的几个常用实现类有：

1. FixedThreadPool：线程数固定的线程池
2. CachedThreadPool：线程数根据任务动态调整的线程池
3. SingleThreadExecutor：仅单线程执行的线程池

创建这些线程池的方法都被封装到Executors这个类中，以FixedThreadPool为例：

import java.util.concurrent.*;

public class Main 
    public static void main(String[] args) 
        // 创建一个固定大小的线程池:
        ExecutorService es = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 6; i++) 
            es.submit(new Task("" + i));
        
        // 关闭线程池:
        es.shutdown();
    


class Task implements Runnable 
    private final String name;

    public Task(String name) 
        this.name = name;
    

    @Override
    public void run() 
        System.out.println("start task " + name);
        try 
            Thread.sleep(1000);
         catch (InterruptedException e) 
        
        System.out.println("end task " + name);
    


//允许结果如下：

start task 0
start task 1
start task 2
start task 3
end task 0
start task 4
end task 1
start task 5
end task 2
end task 3
end task 4
end task 5

运行结果分析：一次性放入6个任务，由于线程池只有固定的4个线程，因此，前4个任务会同时执行，等到有线程空闲后，才会执行后面的两个任务。

线程池在程序结束的时候要关闭。使用shutdown()方法关闭线程池的时候，它会等待正在执行的任务先完成，然后再关闭。shutdownNow()会立刻停止正在执行的任务，awaitTermination()则会等待指定的时间让线程池关闭。

如果我们把线程池改为CachedThreadPool，由于这个线程池的实现会根据任务数量动态调整线程池的大小，所以6个任务可一次性全部同时执行。

如果我们想把线程池的大小限制在4～10个之间动态调整怎么办？

直接安排代码：

     int min = 4;
     int max = 10;
ExecutorService es = new ThreadPoolExecutor(min, max,
        60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());

如果我们想定时让线程跑任务怎么办？

Java标准库还提供了一个java.util.Timer类，这个类也可以定期执行任务，但是，一个Timer会对应一个Thread，所以，一个Timer只能定期执行一个任务，多个定时任务必须启动多个Timer，而一个ScheduledThreadPool就可以调度多个定时任务，所以，我们完全可以用ScheduledThreadPool取代旧的Timer

JDK提供了ExecutorService实现了线程池功能：

• 线程池内部维护一组线程，可以高效执行大量小任务

• Executors提供了静态方法创建不同类型的ExecutorService

• 必须调用shutdown()关闭ExecutorService

• ScheduledThreadPool可以定期调度多个任务

Java线程池的使用

　　本节我们从以上几个方面详细介绍一下Java线程池的使用。

• 　　线程池的创建
• 　　线程池任务提交
• 　　关闭线程池
• 　　线程池的监控
• 　　线程池的合理配置　　

一.线程池的创建

　　我们可以通过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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

　　创建线程池需要输入几个参数：

　　1.corePoolSize(线程池的基本大小)：当提交一个任务到线程池的时候，线程池会创建一个线程来执行任务，即使其他空闲的线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池的基本大小的时候就不在创建。如果调用了线程池的prestartAllCoreThreads，线程池会提前创建并执行新的线程。

　　2.workQueue(任务队列)：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列：

　　　　ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序　　

　　　　LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列

　　　　SynchronousQueue：SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列

　　　　PriorityBlockingQueue：一个具有优先级的无限阻塞队列

　　3.maximumPoolSize(线程池最大数量)：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果

　　4.ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。使用开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字

　　5.RejectedExecutionHandler(饱和策略):当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。在JDK 1.5中Java线程池框架提供了以下4种策略。

　　　　AbortPolicy:直接抛出异常

　　　　CallerRunsPolicy：只用调用者所在线程执行任务

　　　　DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务

　　　　DiscardPolicy：不处理，丢弃掉

　　当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务

　　6.keepAliveTime(线程活动保持时间)：线程池的工作线程空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。

　　7.TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和纳秒（NANOSECONDS，千分之一微秒）。

二.线程池任务提交

　　可以使用两个方法向线程池提交任务，分别是：execute和submit

　　execute用于提交不需要返回任何结果的任务，所以无法判断任务是否被线程池执行成功

　　submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

三.关闭线程池

　　可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别，shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。

　　只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

四.线程池的监控

　　如果在系统中大量使用线程池，则有必要对线程池进行监控，方便在出现问题时，可以根据线程池的使用状况快速定位问题。可以通过线程池提供的参数进行监控，在监控线程池的时候可以使用以下方法。

　　1.getTaskCount：线程池需要执行的任务的数量

　　2.getCompletedTaskCount：线程池在运行过程中已完成的任务数量，小于或等于taskCount

　　3.getLargestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。

　　4.getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。

　　5.getActiveCount：获取活动的线程数

　　通过扩展线程池进行监控。可以通过继承线程池来自定义线程池，重写线程池的beforeExecute、afterExecute和terminated方法，也可以在任务执行前、执行后和线程池关闭前执行一些代码来进行监控。例如，监控任务的平均执行时间、最大执行时间和最小执行时间等。这几个方法在线程池里是空方法

protected void beforeExecute(Thread t, Runnable r) { }

 

五.线程池的合理分配

　　要想合理地配置线程池，就必须首先分析任务特性，可以从以下几个角度来分析：

　　　　任务的性质：CPU密集型任务、IO密集型任务和混合型任务

　　　　任务的优先级：高、中和低

　　　　任务的执行时间：长、中和短

　　　　任务的依赖性：是否依赖其他系统资源，如数据库连接。

　　性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务应配置尽可能小的线程，如配置Ncpu+1个线程的线程池。由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如2*Ncpu。混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。如果这两个任务执行时间相差太大，则没必要进行分解。可以通过
Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。

　　优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先执行。

　　执行时间不同的任务可以交给不同规模的线程池来处理，或者可以使用优先级队列，让执行时间短的任务先执行。

　　依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，等待的时间越长，则CPU空闲时间就越长，那么线程数应该设置得越大，这样才能更好地利用CPU。

　　建议使用有界队列。