（十一）Android的线程和线程池

11.1 主线程和子线程

Android主线程（UI线程）主要处理和界面相关得事情。主要运行四大组件以及处理它们和用户得交互。
Android子线程往往用于执行耗时操作，比如网络请求，I/O操作等。
子线程如何与UI线程通讯：通过handler传Message：

    public static final int UPDATE_TEXT = 1;

    private TextView text;

    private Handler handler = new Handler() {

        public void handleMessage(Message msg) {
            switch (msg.what) {
                case UPDATE_TEXT:
                    // 在这里可以进行UI操作
                    text.setText("Nice to meet you");
                    break;
                default:
                    break;
            }
        }

    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView) findViewById(R.id.text);
        Button changeText = (Button) findViewById(R.id.change_text);
        changeText.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.change_text:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message message = new Message();
                        message.what = UPDATE_TEXT;
                        handler.sendMessage(message); // 将Message对象发送出去
                    }
                }).start();
                break;
            default:
                break;
        }
    }

}

11.2 Android中的线程形态

除了传统得Thread以外：
AsyncTask：底层采用线程池
HandlerThread：底层采用线程
IntentService：底层采用线程

11.2.1 AsyncTask

AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新UI。从实现上来说，AsyncTask封装了Thread和Handler。

/*
抽象类 AsyncTask
Params: 表示参数的类型
Progress: 表示后台任务的执行进度的类型
Result: 表示后台任务的返回结果的类型
*/

public abstract class AsyncTask<Params, Progress, Result> {
    // 主线程中执行，在异步任务执行之前，做一些准备工作
    protected void onPreExecute() {}
    // 在线程池中执行，执行异步任务
    protected abstract Result doInBackground(Params... params);
    // 主线程中执行，在异步任务执行时，随着进度发生变化
    protected void onProgressUpdate(Progress... values) {}
    // 主线程中执行，在异步任务执行之前，做一些准备工作
    protected void onPostExecute(Result result) {}

}

在Android 3.0之后，AsyncTask可以通过execute()方法串行执行，也可以通过executeOnExecutor()方法并行执行。
我们举一个下载文件的例子：

public class DownloadTask extends AsyncTask<String, Integer, Integer> {

    public static final int TYPE_SUCCESS = 0;
    public static final int TYPE_FAILED = 1;
    public static final int TYPE_PAUSED = 2;
    public static final int TYPE_CANCELED = 3;

    private DownloadListener listener;

    private boolean isCanceled = false;

    private boolean isPaused = false;

    private int lastProgress;

    public DownloadTask(DownloadListener listener) {
        this.listener = listener;
    }

    @Override
    protected Integer doInBackground(String... params) {
        InputStream is = null;
        RandomAccessFile savedFile = null;
        File file = null;
        try {
            long downloadedLength = 0; // 记录已下载的文件长度
            String downloadUrl = params[0];
            String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
            String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getPath();
            file = new File(directory + fileName);
            if (file.exists()) {
                downloadedLength = file.length();
            }
            long contentLength = getContentLength(downloadUrl);
            if (contentLength == 0) {
                return TYPE_FAILED;
            } else if (contentLength == downloadedLength) {
                // 已下载字节和文件总字节相等，说明已经下载完成了
                return TYPE_SUCCESS;
            }
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder()
                    // 断点下载，指定从哪个字节开始下载
                    .addHeader("RANGE", "bytes=" + downloadedLength + "-")
                    .url(downloadUrl)
                    .build();
            Response response = client.newCall(request).execute();
            if (response != null) {
                is = response.body().byteStream();
                savedFile = new RandomAccessFile(file, "rw");
                savedFile.seek(downloadedLength); // 跳过已下载的字节
                byte[] b = new byte[1024];
                int total = 0;
                int len;
                while ((len = is.read(b)) != -1) {
                    if (isCanceled) {
                        return TYPE_CANCELED;
                    } else if(isPaused) {
                        return TYPE_PAUSED;
                    } else {
                        total += len;
                        savedFile.write(b, 0, len);
                        // 计算已下载的百分比
                        int progress = (int) ((total + downloadedLength) * 100 / contentLength);
                        publishProgress(progress);
                    }
                }
                response.body().close();
                return TYPE_SUCCESS;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
                if (savedFile != null) {
                    savedFile.close();
                }
                if (isCanceled && file != null) {
                    file.delete();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return TYPE_FAILED;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        int progress = values[0];
        if (progress > lastProgress) {
            listener.onProgress(progress);
            lastProgress = progress;
        }
    }

    @Override
    protected void onPostExecute(Integer status) {
        switch (status) {
            case TYPE_SUCCESS:
                listener.onSuccess();
                break;
            case TYPE_FAILED:
                listener.onFailed();
                break;
            case TYPE_PAUSED:
                listener.onPaused();
                break;
            case TYPE_CANCELED:
                listener.onCanceled();
            default:
                break;
        }
    }

    public void pauseDownload() {
        isPaused = true;
    }


    public void cancelDownload() {
        isCanceled = true;
    }

    private long getContentLength(String downloadUrl) throws IOException {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(downloadUrl)
                .build();
        Response response = client.newCall(request).execute();
        if (response != null && response.isSuccessful()) {
            long contentLength = response.body().contentLength();
            response.close();
            return contentLength;
        }
        return 0;
    }

}

11.2.2 AsyncTask的工作原理

AsyncTask中有两个线程池：THREAD_POOL_EXECUTOR和SERIAL_EXECUTOR；一个Handler：InternalHandler。
直接贴源代码：

public abstract class AsyncTask<Params, Progress, Result> {
    //THREAD_POOL_EXECUTOR用于真正执行任务
    public static final Executor THREAD_POOL_EXECUTOR;
    //SERIAL_EXECUTOR 用于任务排队
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    //InternalHandler 用于将执行环境从线程池换到主线程
    private static InternalHandler sHandler;


}

11.2.3 HandlerThread

HandlerThread继承了Thread，它是一种可以使用Handler的Thread，且具有消息循环的效果。
原理：内部HandlerThread.run()方法中有Looper，通过Looper.prepare()来创建消息队列，并通过Looper.loop()来开启消息循环。

11.2.4 IntentService

为了可以简单地创建一个异步的、会自动停止的服务，Android专门提供了一个集开启线程和自动停止于一身的IntentService类。
IntentService是一种特殊的Service，它继承了Service，是一个抽象类。可用于执行后台耗时任务。它是一个服务，所以优先级比单纯的线程要高。使用方式和普通Service没有区别。

11.3 Android中的线程池

线程池技术：预先创建了若干数量的线程，并且不能由用户直接对线程进行控制，在此基础上复用这些线程完成任务的执行。
好处：
1、消除了频繁创建和消亡线程的系统资源开销。
2、面对过量任务的提交能够平缓的劣化。
本质：
使用了一个线程安全的工作队列连接生产者和消费者。

线程池.png

11.3.1 ThreadPoolExecutor

Android中的线程池概念来源于java中的Executor，Executor是一个接口，真正的线程池实现是ThreadPoolExecutor。来看ThreadPoolExecutor的构造函数源码：

    public ThreadPoolExecutor(int corePoolSize, // 核心线程数
                              int maximumPoolSize, // 最大线程数
                              long keepAliveTime, // 非核心线程闲置时的超时时长
                              TimeUnit unit, //参考时间单位
                              BlockingQueue<Runnable> workQueue, // 任务队列
                              ThreadFactory threadFactory) // 线程共存

我们来看一下AsyncTask的线程池配置：

public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
}

※　核心线程数量为２到４；
※　最大线程数为CPU核心数量的２倍＋１
※　闲置超时时间为３０秒
※　任务队列容量１２８

11.3.2 线程池的分类

Android线程池分4类：
1、FixedThreadPool：只有核心线程，数量固定，任务队列没有大小限制。
2、CachedThreadPool：只有非核心线程，任务队列相当于空，适合执行大量的耗时较少的任务。
3、ScheduledThreadPool：核心线程数量固定，非核心线程数量没有限制
4、SingleThreadPool：只有一个核心线程