创建线程的另一种方法-使用Android线程池

在开发过程中，经常会使用到线程，一般使用Thread或Runnable来创建一个线程，使用这种方式创建的线程并不能被重复利用。当应用程序中创建的线程对象太多时，随之而来的是由于创建和销毁线程所带来的性能开销，多线程的并发也会因互相抢占系统资源而导致程序阻塞。使用线程池可以避免这些问题，总的来说，线程池有以下几点好处

1、重用线程池中的线程，避免因为线程创建和销毁带来的性能开销
2、有效的控制线程的最大并发数，避免大量的线程之间因互相抢占资源而导致的阻塞现象
3、对线程进行简单的管理，并提供定时执行及间隔循环执行等功能

Android中线程池的概念来源于Java中的Executor，Executor是一个接口，线程池的实现类是ThreadPoolExecutor，Android中的线程池主要分为4类，都是通过ThreadPoolExecutor直接或间接配置实现的，所以首先来了解一下ThreadPoolExecutor

ThreadPoolExecutor

ThreadPoolExecutor是线程池的实现类，它的构造方法中提供了一系列参数来配置线程池。下面是一个ThreadPoolExecutor比较常用的构造方法

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAlivetime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory)

构造方法的参数比较多，一个一个来看

corePoolSize:

线程池的核心线程数。默认情况下，核心线程会在线程池中一直存货，即使处于闲置状态。如果将ThreadPoolExecutor的allowCoreTimeout属性设为true，那么闲置的核心线程在等待任务到来时会有超时策略。如果等待时间超过keepAliveTime所指定的时长，核心线程就会被终止

maximumPoolSize

线程池所能容纳的最大线程数，当活动的线程达到这个数值后，后续的新任务将会被阻塞

keepAliveTime

非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收。当ThreadPoolExecutor的allowCoreThreadTimeout属性设为true时，同样会作用于核心线程

unit

用于指定keepAliveTime参数的时间单位，枚举类型，常用的有TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、以及TimeUnit.MINUTES等

workQueue

线程池中的任务队列，通过线程池的execute方法提交的Runnable对象会存储在这个参数中

threadFactory

线程工厂，为线程池提供创建新线程的功能。ThreadFactory是一个接口，它只有一个方法：Thread newThread(Runnable r)

ThreadPoolExecutor执行任务时大致遵循如下规则：

1、如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务

2、如果线程池中的线程数量已经达到或超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行

3、如果无法将任务插入到任务队列中，这往往是由于任务队列已满，这时如果线程数量未达到线程池规定的最大值，会立刻启动一个非核心线程来执行任务

Android中主要有4类常见的线程池，他们都直接或间接通过ThreadPoolExecutor配置来实现

1、FixedThreadPool

一种线程数量固定的线程池，并且只有核心线程，线程处于空闲时也不会回收。如果所有线程都处于活动状态，新任务会进入等待队列，直到有线程空闲出来。由于FixedThreadPool只有核心线程并且不会被回收，所以能够更快地响应外界的请求。使用Executors的newFixedThreadPoll()方法创建

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

从构造方法发现，FixedThreadPool中只有核心线程，并且这些核心线程没有超时限制，另外任务队列大小也没有限制

线程使用方法

Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                SystemClock.sleep(2000);
                Log.i(TAG, "Current thread:" + Thread.currentThread());
            }
        };

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
        fixedThreadPool.execute(runnable);
        fixedThreadPool.execute(runnable);
        fixedThreadPool.execute(runnable);

上述代码创建了一个最大线程数为2的线程池，并且启动了3个任务，运行程序

由于线程池的最大线程数为2， 所以前2个任务执行完以后才可以执行第3个任务

2、CacheThreadPool

这是一种线程数量不固定的线程池，线程池中的线程数可以无限大，只有非核心线程。当线程池中的所有线程都处于活动状态时，会创建新的线程来执行任务，否则就会利用空闲的线程来执行，线程池中的线程都有超时限制，超时时长为60秒，超过60秒闲置线程就会被回收，CachedThreadPool的任务队列相当于一个空集合，这将导致任何任务都会立即执行。当整个线程池都处于闲置状态时，线程中的线程都会超时而停止，这时CachedThreadPool中是没有任何线程的，它几乎不占用任何系统资源。使用Executors的newCachedThreadPool创建线程池。

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

线程池使用方法

Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                SystemClock.sleep(2000);
                Log.i(TAG, "Current thread:" + Thread.currentThread());
            }
        };

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(runnable);
        cachedThreadPool.execute(runnable);
        cachedThreadPool.execute(runnable);

运行结果

由于线程池可以容纳的线程数为无限多，任何任务都会立即执行，所以3个任务是同时开始执行的

3、ScheduledThreadPool

核心线程数量固定，非核心线程数量没有限制，非核心线程闲置时被立即回收。主要用于执行定时任务和具有固定周期的重复任务。使用Executors的newScheduledThreadPool()方法创建

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

线程使用方法

Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                SystemClock.sleep(2000);
                Log.i(TAG, "Current thread:" + Thread.currentThread());
            }
        };

ScheduledExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(3);
        //2秒后执行runnable
        scheduleThreadPool.schedule(runnable, 3000, TimeUnit.MILLISECONDS);
        //1秒后执行runnable,每隔3秒执行一次
        scheduleThreadPool.scheduleAtFixedRate(runnable, 1000, 3000, TimeUnit.MILLISECONDS);

运行结果

4、SingleThreadPool

线程池内部只有一个核心线程，确保所有的任务都在同一个线程中按顺序执行。SingleThreadPool的意义在于统一所有外界的任务到一个线程中，使得这些任务之间不需要处理线程同步的问题。使用Executors的newSingleThreadExecutor()方法创建

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }

线程使用方法

Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                SystemClock.sleep(2000);
                Log.i(TAG, "Current thread:" + Thread.currentThread());
            }
        };

        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        singleThreadPool.execute(runnable);
        singleThreadPool.execute(runnable);
        singleThreadPool.execute(runnable);

运行结果

线程池中只有一个线程，每次只能执行一个任务，所以3个任务是依次执行的

博客内容参考资料：Android开发艺术探索