Android多线程的五种方式，我该怎么选择

Android多线程在应用中被广泛使用，多线程操作也有多种方法。
这次就和大家一起熟悉下Android中多线程的操作方法，以及到底在实际应用场景下该怎么选择

多线程操作方法

Android中，主要提供了以下几种多线程操作方法：

• Thread，Runnable
• HandlerThread
• AsyncTask
• Executor
• IntentService

1、Thread，Runnable

首先介绍Android中创建线程最基本的两种方法，用到了Thread类和Runnable接口，直接上代码

    /**
     * 继承Thread
     */
    public class NewThread extends Thread{
        @Override
        public void run() {
            super.run();
        }
    }

    /**
     * 实现Runnable接口
     */
    public class NewThread2 implements Runnable{
        @Override
        public void run() {

        }
    }

这里也没有什么更多的说的，都是线程最基础的用法，一般用于界面上比较简单的快捷用法。
在Android中一般跟Handler一起使用，用于线程中的通信。那Android中为了方便这种通信方式，就生成了一个HandlerThread类，将Thread和Handler结合起来方便了使用。
下面我们来看看HandlerThread。

2、HandlerThread

HandlerThread的本质其实是继承自Thread类，并且对Thread类进行了一个封装。
主要解决的问题是，在一个已经运行的线程中去执行一些任务。
官方解释是：

• Thread. Handy class for starting a new thread that has a looper.
• The looper can then be used to create handler classes.

我们先看看使用代码吧：

        HandlerThread mHandlerThread=new HandlerThread("");
        mHandlerThread.start();

        Handler mHandler =new Handler(mHandlerThread.getLooper()){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
            }
        };

        mHandler.sendEmptyMessage(0);

代码很清楚表示了，HandlerThread在运行中，可以通过handler进行一些任务处理。

它的原理其实就是在HandlerThread线程内部有一个Looper变量，进行loop()的死循环，然后通过MessageQueue进行一系列任务的排队和处理。
那有人就会问了，这不就是普通的Thread+Looper+Handler吗，其实差不太多，HandlerThread就相当于系统帮你封装了一个带looper对象的线程，不需要你自己去手动操作Looper

那么这个HandlerThread到底有什么实际应用呢？
一般用于Android中需要新建子线程进行多个任务处理，并且需要和主线程通信。后面要说的IntentService 内部其实就是用了HandlerThread实现的。（其实我个人在实际项目中用的很少，一般用Executors.newSingleThreadExecutor()方法代替，一样的线程中管理任务队列，后面会详细说到线程池）

3、AsyncTask

AsyncTask 是一种***轻量级的异步任务类***，可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程用于更新UI。
刚才说到如果需要新建线程进行多个任务处理并且完成和主线程通信，就可以用到HandlerThread(或者Executors.newSingleThreadExecutor())，那么如果是单一任务呢，简单的任务呢？
比如我就需要请求一个接口，然后进行UI更新，那么就可以用到AsyncTask，它的优点在于***简单快捷，过程可控***。见示例：

new AsyncTask<Void, Void, String>() {

    @Override
    protected void onPreExecute() {
        //请求接口之前，初始化操作
        super.onPreExecute();
    }

    @Override
    protected String doInBackground(Void... parameters) {
        //请求接口
        return "";
    }

    @Override
    protected void onProgressUpdate(Void... values) {
        //在主线程显示线程任务执行的进度
        super.onProgressUpdate(values);
    }

    @Override
    protected void onPostExecute(String responseString) {
        //接收线程任务执行结果
    }
}.execute();

4、Executor

Executor类提供了一组线程池，可以管理多个线程并行执行，线程池的优点就在于可以线程复用，并且合理管理所有线程。

这里主要讲三种创建线程池的方法：

        //固定大小的线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
        //不限制线程上限的线程池
        ExecutorService pool2 = Executors.newCachedThreadPool();
        //只有一个线程的线程池
        ExecutorService pool3 = Executors.newSingleThreadExecutor();

其中为什么newSingleThreadExecutor可以代替HandlerThread呢，因为他也是可以串行执行所有任务，一个线程结束，下面一个线程代替并执行。至于和主线程通信，还是可以用handler或者其他常规的通信方式。

具体的关于线程池的内容呢，大家可以点击查看之前的一篇专门说线程池的文章，这里就不再细说了。

5、IntentService

IntentService 是一个继承自Service，自带工作线程，并且线程任务结束后自动销毁的一个类。
Service是啥？可以统一管理后台任务，运行在前台，所以可以获取到上下文。
而IntentService同样具有这些特性，并且可以在新线程管理任务，工作执行完自动销毁。就线程池来说区别就在与IntentService拥有Service的特性，所以在需要用到上下文的时候就可以选择IntentService。
这里可以直接看看IntentService源码：

		@Override
    public void onCreate() {
			  super.onCreate();
			  //创建新线程并start
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        mServiceLooper = thread.getLooper();
        //创建新线程对应的handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
    		//service启动后发送消息给handler
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }
    
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {
        		//handler收到消息后调用onHandleIntent方法
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }

到此就差不多分析完了，其实就是开了一个线程，通过handler，到onHandleIntent方法执行

五种方式，怎么选择呢？

这里我给的建议是：

• 轻量级，简单的任务可以直接用 AsyncTask
• 需要后台管理，用到上下文的时候用IntentService
• 其余场景都用线程池，毕竟线程池是最推荐，最优化的线程管理方法