前言

多任务处理在现实开发场景中已经无处不在，通过多任务处理可以将计算机性能更大程度的发挥出来，避免处于空闲状态浪费性能。
对于计算量相同的任务，程序线程并发协调得越有条不紊，效率自然就会越高；反之，线程之间频繁争用数据，互相阻塞甚至死锁，将会大大降低程序的并发能力。
因此我们有必要深入了解多线程开发。

1 概念

在说线程之前我们先来了解进程、线程、线程池概念。

进程（process）是指在系统中正在运行的一个应用程序。
线程（Thread）是比进程更轻量级的调度执行单位，它可以把一个进程的资源分配和执行调度分开。目前线程是CPU调度执行的最基本单位。
线程池（ThreadPool）自动创建、销毁线程的一个容器。

2 线程

不建议直接new线程，因为存在以下几点问题：
①不易复用，频繁创建及销毁开销大
②特定场景不易使用，例如定时任务
一个简单的线程实现方式

  fun doSomething() {
        Thread{
            //todo
        }.start()
    }

3 线程池

线程池的优点：
①可重用线程池中的线程，避免频繁创建及销毁带来的性能开销。
②可控制最大并发数，避免大量线程之间因为相互抢占系统资源而导致阻塞。
③支持特定场景使用，例如定时任务。
我们日常开发中所使用到的线程池在java.util.concurrent并发工具包下，继承自Executor实现了ThreadPoolExecutor，ThreadPoolExecutor提供了一系列参数配置线程，如下所示：

/**
     *
     * @param corePoolSize 核心线程数，默认情况一直存活
     *      
     * @param maximumPoolSize 线程池最大线程数
     *        
     * @param keepAliveTime 非核心线程闲置时的超时时长，超过这个时长就会被           
     *  回收。当allowCoreThreadTimeOut设置为true时作用于核心线程 。
     *   
     * @param unit 指定keepAliveTime存活时常的单位，TimeUnit是个枚举类，一般 
     * 有TimeUnit.SECONDS，TimeUnit.MINUTES
     *       
     * @param workQueue 线程池任务队列，通过execut提交Runnable执行。
     *    
     * @param threadFactory 当创建新线程时可以使用该工厂创建
     *   
     * @throws 满足以下条件抛出此异常   IllegalArgumentException 
     *         {corePoolSize < 0}
     *         {keepAliveTime < 0}
     *         {maximumPoolSize <= 0}
     *         {maximumPoolSize < corePoolSize}
     * @throws NullPointerException  workQueue、threadFactory为null时抛出异常。
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

除以上参数外，还有一个参数RejectedExecutionHandler，当任务队列已满或者是无法成功执行任务，就会调用RejectedExecutionHandler的rejectedExecution，默认抛出异常。ThreadPoolExecutor还为我们提供了CallerRunsPolicy、AbortPolicy、DiscardPolicy、DiscardOldestPolicy四种Handler，默认为AbortPolicy，因此是直接抛出异常。

    public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

一个简单的线程池工具类创建如下:

 private int CPU_Runtime = Runtime.getRuntime().availableProcessors() + 1;

 public ThreadPoolExecutor threadPoolExecutor;

 public ThreadPoolUtils() {
        threadPoolExecutor = new ThreadPoolExecutor(CPU_Runtime, CPU_Runtime, 
                1, TimeUnit.MINUTES,
                new LinkedBlockingQueue<Runnable>(128),
                new MyThreadFactory("test"));
    }

    /**
     * 记录是线程池中第几个线程
     */
    private static class MyThreadFactory implements ThreadFactory {

        private final String name;
        private final AtomicInteger mCount = new AtomicInteger(1);

        MyThreadFactory(String name) {
            this.name = name;
        }

        @Override
        public Thread newThread(@NonNull Runnable r) {
            return new Thread(r, name + "-" + mCount.getAndIncrement() + "-");
        }
    }

根据实际开发需求做了以上这些配置，配置参数规格如下：

核心线程数为CPU核心数+1
非核心线程数与核心线程数相同
非核心线程超时时间为1分钟
任务队列容量为128
使用工厂模式创建线程，便于查看当前执行的线程相关信息。

4 常用的4种线程池

java还为我们实现了配置了4种常用的线程池，newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool、newSingleThreadExecutor，它们都直接或间接配置了ThreadPoolExecutor。

4.1 newFixedThreadPool

固定线程数的线程池，当处于空闲状态不会被回收。因为最大线程数和核心线程相等，所以都是核心线程，处于空闲状态不会被回收。

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

4.2 newCachedThreadPool

数量不固定的线程池，因为最大线程数为Integer.MAX_VALUE，但是一般不会创建太多，因为创建线程开销比较消耗性能。默认超时时长为60S。

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

4.3 newScheduledThreadPool

创建固定数量的核心线程以及Integer.MAX_VALUE非核心线程，默认超时时长为10分钟，一般用于执行固定周期的重读任务。

  private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
  public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

   public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

4.4 newSingleThreadExecutor

只有一个核心线程的线程池，它保证了所有的线程在此队列中都是有序执行的。一般用于统一外界任务，避免处理同步问题。

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

总结

java.util.concurrent为我们提供了线程池的创建，方便我们管理线程，但随着变成语言的发展，协程也出现在了我们日常开发中，无论是Java即将面世的迁程（Fiber）或者kotlin的协程(Coroutines)，它们的创建与销毁的开销远远小于线程的创建，因此在使用kotlin开发Android时建议多使用协程进行多并发开发。

Android线程池的使用