Android 多线程编程 - 线程池

2023-07-26  本文已影响0人  BlueSocks

前言

在编程中经常会使用线程来异步处理任务，但是每个线程的创建和销毁都需要一定的开销。如果每次执行一个任务都需要开一个新线程去执行，则这些线程的创建和销毁将消耗大量的资源；并且线程都是“各自为政”的，很难对其进行控制，更何况有一堆的线程在执行。这时就需要线程池来对线程进行管理。在Java1.5中提供了Executor框架用于任务的提交和执行解耦，任务的提交交给Runnable或者Callable，而Executor框架用来处理任务。Executor框架中最核心的成员是ThreadPoolExecutor，它是线程池的核心实现类。

1. ThreadPoolExecutor

可以通过ThreadPoolExecutor来创建一个线程池，ThreadPoolExecutor类一共有4个构造方法。其中，拥有参数最多的构造方法如下所示：

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

这些参数的作用如下：

2. 线程池的处理流程和原理

线程池的处理流程主要分为3个步骤，如下所示：

  1. 提交任务后，线程池先判断线程数是否到达了核心线程数（corePoolSize）。如果未到达核心线程数，则创建核心线程处理任务；否则执行下一步操作。

  2. 接着线程池判断任务队列是否满了。如果没满，则将任务添加到任务队列中；否则就执行下一步操作。

  3. 这时，因为任务队列满了，所以线程池就判断线程数是否达到了最大线程数。如果未达到最大线程数，则创建非核心线程处理任务。否则，就执行饱和策略，默认会抛出RejectedExecutionException异常。

补充：线程池的空闲线程会不断从任务队列中取出任务进行处理。

3. 线程池的种类

通过直接或者间接的配置ThreadPoolExecutor的参数可以创建不同类型的ThreadPoolExecutor，其中有4种线程池比较常用，它们分别是FixedThreadPool、CachedThreadPool、SingleThreadExecutor和SechduledThreadPool。

3.1. FixedThreadPool

FixedThreadPool是可重用固定线程数的线程池。在Executors类中提供了创建FixedThreadPool的方法，如下所示：

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

FixedThreadPool的corePoolSize和maximumPoolSize都设置为创建FixedThreadPool指定的参数nThreads，也意味着FixedThreadPool只有核心线程，并且数量是固定的，没有非核心线程。keepAliveTime设置为0L意味着多余线程会被立即终止。因为不会产生多余线程，所以keepAliveTime是无效的参数。另外，任务队列采用了无界阻塞队列LinkedBlockingQueue（容量默认为Integer.MAX_VALUE）。

3.2. CachedThreadPool

CachedThreadPool是一个根据需要创建线程的线程池，创建CachedThreadPool的代码如下：

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, 2147483647, 60L, 
                            TimeUnit.SECONDS, new SynchronousQueue());
    }

CachedThreadPool的corePoolSize为0，maximumPoolSize设置为Integer.MAX_VALUE，这意味着CachedThreadPool没有核心线程，非核心线程是无界的。keepAliveTime设置为60L，则空闲线程等待新任务的最长时间为60s。在此用了阻塞队列SynchornousQueue，它是一个不存储元素的阻塞队列，每个插入操作必须等待另一个线程的移除操作，同样任何一个线程的移除操作都等待另一个线程的插入操作。

当执行executor方法时，首先会执行SynchronousQueue方法的offer方法来提交任务，并且查询线程池中是否有空闲的线程执行SynchronousQueue的pol方法来移除任务。如果有则配对成功，将任务交给这个空闲的线程处理；如果没有，则配对失败，创建新的线程去处理任务。当线程池中的线程空闲时，它会执行SynchoronousQueue的poll方法，等待SynchronousQueue中新提交的任务。如果超过60s没有新任务提交到SynchronousQueue，则这个空闲线程将终止。因为maximumPoolSize是无界的，所以如果提交的任务大于线程池中线程处理任务的速度，就会不断创建新线程。另外，每次提交任务都会立即有线程去处理。所以，CachedThreadPool比较适于大量的需要立即处理并且耗时较少的任务。

3.3. SingleThreadExecutor

SingleThreadExecutor是使用单个工作线程的线程池，其创建源码如下所示：

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

corePoolSize和maximumPoolSize都为1，意味着SingleThreadExecutor只有一个核心线程，其他的参数都和FixedThreadPool一样，这里就不赘述了。

当执行execute方法时，如果当前运行的线程数未达到核心线程数，也就是当前没有运行的线程，则创建一个新线程来处理任务。如果当前有运行的线程，则将任务添加到阻塞队列LinkedBlockingQueue中。因此，SingleThreadQueue能确保所有的任务在一个线程中按照顺序逐一执行。

3.4. ScheduledThreadPool

ScheduledThreadPool是一个能实现定时和周期性任务的线程池，它的创建源码如下所示：

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


    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, 2147483647, 10L, TimeUnit.MILLISECONDS,
             new ScheduledThreadPoolExecutor.DelayedWorkQueue());
    }

从上面的代码可以看出，ScheduledThreadPoolExecutor的构造方法最终调用的是ThreadPoolExecutor的构造方法。corePoolSize是传进来的固定数值，maximumPoolSize的值是Integer.MAX_VALUE。因为这里采用的DelaydWorkQueue是无界的，所以maximumPoolSize这个参数是无效的。

当执行SecheduledThreadPoolExecutor的scheduleAtFixedTRate或者schedueWithFixedDelay方法时，会向DelayedWorkQueue添加一个实现RunnableScheduledFuture接口的ScheduledFutureTask（任务的包装类），并会检查运行的线程数是否达到了corePoolSize（核心线程数）。如果没有达到，则新建线程并启动它，但并不是立即去执行任务，而是去DelayedWorkQueue中取ScheduledFutureTask，然后执行任务。如果运行的线程数达到了corePoolSize时，则将任务添加到DelayedWorkQueue中。DelayedWorkQueue会将任务进行排序，先要执行的任务放在队列的前面。其跟此前介绍的线程池不同的是，当执行完任务后，会将ScheduledFutureTask中的time变量改为下次要执行的时间并放回DelayedWorkQueue中。

上一篇下一篇

猜你喜欢

热点阅读