Android 四种线程池

为什么要使用线程池

1. 当同时并发多个网络线程时，引入线程池技术会极大地提高APP的性能。
2. 显著减少了创建线程的数目。
3. 防止内存过度消耗。控制活动线程的数量，防止并发线程过多。
   使用条件：假设在一台APP完成一项任务的时间为T
   
   • T1 创建线程的时间
   • T2 在线程中执行任务的时间，包括线程间同步所需时间
   • T3 线程销毁的时间

显然T ＝ T1＋T2＋T3。注意这是一个极度简化的假设。可以看出T1,T3是多线程本身的带来的开销，我们渴望减少T1,T3所用的时间，从而减少T的时间。但一些线程的使用者并没有注意到这一点，所以在程序中频繁的创建或销毁线程，这导致T1和T3在T中占有相当比例。显然这是突出了线程的弱点（T1，T3），而不是优点（并发性）。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高APP程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

四种线程池各自的特点

1. newCachedThreadPool()
   缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中。能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。缓存型池子通常用于执行一些生存期很短的异步型任务 。
2. newFixedThreadPool()
   fixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程 其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子。和cacheThreadPool不同：fixedThreadPool池线程数固定，但是0秒IDLE（无IDLE）。这也就意味着创建的线程会一直存在。所以fixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器。
3. newScheduledThreadPool()
   调度型线程池。这个池子里的线程可以按schedule依次delay执行，或周期执行 。0秒IDLE（无IDLE）。
4. SingleThreadExecutor
   单例线程，任意时间池中只能有一个线程 。用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）。

从一个Demo开始

package com.example.executortest;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

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

public class MainActivity extends Activity implements View.OnClickListener {

    private static final String TAG = "Executor";

    /** 总共多少任务（根据CPU个数决定创建活动线程的个数,这样取的好处就是可以让手机承受得住） */
    // private static final int count = Runtime.getRuntime().availableProcessors() * 3 + 2;

    /** 总共多少任务 */
    private static final int count = 3;

    /** 所有任务都一次性开始的线程池 */
    private static ExecutorService mCacheThreadExecutor = null;

    /** 每次执行限定个数个任务的线程池 */
    private static ExecutorService mFixedThreadExecutor = null;

    /** 创建一个可在指定时间里执行任务的线程池，亦可重复执行 */
    private static ScheduledExecutorService mScheduledThreadExecutor = null;

    /** 每次只执行一个任务的线程池 */
    private static ExecutorService mSingleThreadExecutor = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        initExecutorService();
        Log.i(TAG, "onCreate");

    }

    private void initExecutorService() {
        mCacheThreadExecutor = Executors.newCachedThreadPool();// 一个没有限制最大线程数的线程池
        mFixedThreadExecutor = Executors.newFixedThreadPool(count);// 限制线程池大小为count的线程池
        mScheduledThreadExecutor = Executors.newScheduledThreadPool(count);// 一个可以按指定时间可周期性的执行的线程池
        mSingleThreadExecutor = Executors.newSingleThreadExecutor();// 每次只执行一个线程任务的线程池
    }

    private void initView() {
        findViewById(R.id.mCacheThreadExecutorBtn).setOnClickListener(this);
        findViewById(R.id.mFixedThreadExecutorBtn).setOnClickListener(this);
        findViewById(R.id.mScheduledThreadExecutorBtn).setOnClickListener(this);
        findViewById(R.id.mSingleThreadExecutorBtn).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.mCacheThreadExecutorBtn:
                ExecutorServiceThread(mCacheThreadExecutor);
                break;
            case R.id.mFixedThreadExecutorBtn:
                ExecutorServiceThread(mFixedThreadExecutor);
                break;
            case R.id.mScheduledThreadExecutorBtn:
                ExecutorScheduleThread(mScheduledThreadExecutor);
                break;
            case R.id.mSingleThreadExecutorBtn:
                ExecutorServiceThread(mSingleThreadExecutor);
                break;
        }
    }

    private void ExecutorServiceThread(ExecutorService executorService) {
        for (int i = 0; i < 9; ++i) {
            final int index = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    Log.i(TAG, "Thread:" + Thread.currentThread().getId() + " activeCount:" + Thread.activeCount() + " index:" + index);
                }
            });
        }
    }

    private void ExecutorScheduleThread(ScheduledExecutorService scheduledExecutorService) {
        for (int i = 0; i < 9; ++i) {
            final int index = i;
            scheduledExecutorService.schedule(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2 * 1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    Log.i(TAG, "Thread:" + Thread.currentThread().getId() + " activeCount:" + Thread.activeCount() + " index:" + index);
                }
            },2, TimeUnit.SECONDS);
        }
    }
}

布局四个Button就不贴了，分别对应newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool、newSingleThreadExecutor。

60s之内点击两次mCacheThreadExecutorBtn，60s后再次点击

从代码中我们可以知道，每次点击输出9条Log。由强迫症的同学可能会问为什么是9条而不是整数10，我会告诉你：因为我愿意！

一共三次点击，一大段空格和光标为分界线。仔细对比可以发现：第一次点击开启了9个线程。没有复用任何线程，60s内第二次点击，全部复用了第一次点击开启的线程。60s后第三次点击，由于IDLE机制，原来开启的线程被自动终止，重新开启了9个新线程。

点击mFixedThreadExecutorBtn，60s后再次点击

两次点击，光标为分割线。代码中可以看到：mFixedThreadExecutor = Executors.newFixedThreadPool(3);设置线程池的最大数量为3。看到这里有强迫症的小伙伴是不是突然觉得上文9条Log的9是不是爽了一些。毕竟是3的整数倍。从输出的log可以看出第一次创建了125、126、127三个线程。而在这之后，无论多长时间再次点击mFixedThreadExecutorBtn，都在复用已经创建了的3个线程。0秒IDLE（无IDLE）。

点击mScheduledThreadExecutorBtn，60s后再次点击

两次点击，光标为分割…割…割线。这个和mFixedThreadExecutor一样，区别是首次创建Thread有个启动延迟时间，本Demo是2s。0秒IDLE（无IDLE）

点击mSingleThreadExecutorBtn，60s后再次点击

两次点击，光标为分割线。Log显示这种线程池从创建122线程之后就一直复用这个线程。心疼newSingleThreadExecutor线程池，身为一个“池”，居然只能装下一个线程。唯一的用处是保证所有任务按照FIFO(First In First Out)顺序执行。