Android中的线程池详解

Android常见的线程池有四种，分别是FixThreadPool、CachedThreadPool、ScheduledThreadPool、SingleThreadExecutor。他们都是直接或间接通过配置ThreadPoolExecutor来实现自己的功能特性的。所以下面我们首先来介绍ThreadPoolExecutor这个类。

ThreadPoolExecutor

ThreadPoolExecutor的构造方法提供了一系列的参数来配置线程池，下面来介绍ThreadPoolExecutor的构造方法中各个参数的含义，这些参数会直接影响线程池的功能特性，下面是ThreadPoolExecutor的比较常用的构造方法。

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

corePoolSize
线程池的核心线程数，默认情况下，核心线程会在线程池一直存活，即使他们处于闲置状态。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true,那么闲置的核心线程在等待新任务到来时会有超时策略，这个时间间隔由keepAliveTime指定。超时核心线程就会被终止。

maximumPoolSize
线程池所容纳的最大线程数。活动线程数超过这个数字后，后续任务会被阻塞等待。

keepAliveTime
超时时长，超过这个时长，非核心线程就会被回收。如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，同样会作用于核心线程。

unit
用于指定keepAliveTime参数的时间单位。这是个枚举。常用有TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）等。

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

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

除了上面的主要参数外，还有一个不常用的参数RejectedExecutionHandler handler。当线程池无法执行新任务时，这可能是由于任务队列已满或者是无法执行任务，这个时候ThreadPoolExecutor会调用handler的rejectedExecution方法来通知调用者。默认情况下rejectedExecutor方法会直接抛出一个RejectedExecutionExecption。

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

（1）线程池线程数未到达核心线程数，就会直接启动一个核心线程来执行任务。
（2）线程池中的线程数达到或超过核心线程数，那么任务就会插入到任务队列中排队执行。
（3）如果在步骤2中无法将任务插入到任务队列中，这个时候线程数量未达到线程池最大值，那将启动一个非核心线程来执行任务。
（4） 如果步骤3中线程数量达到了线程池的最大值，那么会拒绝执行任务。会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者。

接下来介绍android中四种常用的线程池

FixedThreadPool

通过Executors的newFixedThreadPool方法来创建。他是一种线程数量固定的线程池，且这些线程都是核心线程并且这些核心线程没有超时机制，另外任务队列也是没有大小限制的。当线程空闲时，它们都不会被回收，除非线程池被关闭。所以它能够很迅速的响应外界的请求。

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

CachedThreadPool

通过Executors的newCachedThreadPool方法来创建。它只有非核心线程，且其最大线程数为Integer.MAX_VALUE。当线程池中线程都处于活动状态时，线程池会创建新的线程来处理新任务，线程中的空闲线程都有超时机制，这个超时机制为60秒。这类线程比较适合执行大量的耗时较少的任务。

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

ScheduledThreadPool

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

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

SingleThreadExecutor

通过Executors的newSingleThreadExecutor方法来创建。它只有一个核心线程，没有非核心线程。所有任务都在同一个线程中按顺序执行。

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

简单示例

下面是一个简单的线程池帮助类

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


/**
 * TODO: 线程池工具类
 * 
 * @author liuxin
 * @date 2018-1-27 下午3:03:40
 * @version 0.1.0 
 */
public class ThreadUtils {
    private static final String TAG = "ThreadUtils";
    private static volatile ThreadUtils instance = null;

    // private constructor suppresses
    private ThreadUtils() {

    }

    public static ThreadUtils getInstance() {
        // if already inited, no need to get lock everytime
        if (instance == null) {
            synchronized (ThreadUtils.class) {
                if (instance == null) {
                    instance = new ThreadUtils();
                }
            }
        }

        return instance;
    }

    /**
     * 初始化的线程数，4个核心线程数
     */
    public ExecutorService threadPool = Executors.newFixedThreadPool(4);

    /**
     * 单一个核心线程
     */
    static ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();

    /**
     * 执行延迟任务线程
     */
    public ScheduledExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(2);

    /**
     * 立即执行任务
     * 
     * @param task ThreadUtils.getInstance().excute(run);
     */
    public void excute(Runnable task) {
        threadPool.execute(task);
    }

    /**
     * 单线程持操作，主要用于数据库的读写异步操作
     * 
     * @param task
     *            ThreadUtils.getInstance().excuteSingleThread(run);
     * @return 
     */
    public Future excuteSingleThread(Runnable task) {
        return singleThreadPool.submit(task);
    };

    /**
     * 延后执行任务
     * 
     * @param task
     * @param delay ThreadUtils.getInstance().schedule(run,1000);
     */
    public void schedule(Runnable task, long delay) {
        scheduleThreadPool.schedule(task, delay, TimeUnit.MILLISECONDS);
    }




    /**
     * @Title: shutdownThreadPool
     * @Description: TODO()
     * @return void 返回类型
     * 在onDestory ()中执行[ThreadUtils.getInstance().shutdownThreadPool()]
     */
    public void shutdownThreadPool() {
        threadPool.shutdownNow();
    }

    /**
     * @Title: shutdownThreadPool
     * @Description: TODO()
     * @return void 返回类型
     * 在onDestory ()中执行[ThreadUtils.getInstance().shutdownScheduleThreadPool()]
     */
    public void shutdownScheduleThreadPool() {
        scheduleThreadPool.shutdownNow();

    }

    /**
     * @Title: shutdownSingleThreadPool
     * @Description: TODO(单线程池销毁操作)
     * @return void 返回类型
     * 在onDestory()中执行[ThreadUtils.getInstance().shutdownSingleThreadPool()]
     */
    public  void shutdownSingleThreadPool() {
        singleThreadPool.shutdownNow();
    }   
}

还有个特殊需求，线程中返回结果，如

/**
*根据银行卡号获取哪个银行，在主线程调用即可
*@param context 上下文
*@param bank 银行卡号
*/
  private void getBank(final Context context, final String bank) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                if (TextUtils.isEmpty(bank) || bank.length() < 6) {
                    return "";
                }
                String prefix = bank.substring(0, 6);
                String ppbank = "";
                InputStream inputStream = null;
                InputStreamReader inputStreamReader = null;
                try {
                    inputStream = context.getAssets().open("bank.json");
                    inputStreamReader = new InputStreamReader(inputStream, "utf-8");
                    Gson gson = new Gson();
                    List<Bank> banks = gson.fromJson(inputStreamReader, new TypeToken<List<Bank>>() {
                    }.getType());
                    if (banks != null && banks.size() > 0) {
                        for (int i = 0; i < banks.size(); i++) {
                            if (banks.get(i).getPrefix().equals(prefix)) {
                                ppbank = banks.get(i).getBank();
                                break;
                            }

                        }
                    }

                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (inputStreamReader != null) {
                        try {
                            inputStreamReader.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (inputStream != null) {
                        try {
                            inputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                return ppbank;
            }
        });
        try {

            String result = future.get();
            if (!TextUtils.isEmpty(result)) {
                etCardName.setText(result);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            future.cancel(true);
        } catch (ExecutionException e) {
            future.cancel(true);
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

    }

后言

参考自《Android开发艺术探索》