本文出自门心叼龙的博客，属于原创类容，转载请注明出处。

做过Android开发的我们都知道，如果在UI主线程中有耗时的操作就有可能会导致应用程序无响应而直接崩溃掉，所以通常情况下如果有耗时的操作，如网络请求或者IO的操作，都会单独的启动一个子线程来完成，这样就避免了UI线程被阻塞而导致的界面卡顿或者崩溃问题。

进程就是正在进行的程序，线程是一个单一顺序的程序执行流，而线程池是线程的一种使用模式，是多线程一种处理形式，一般都会把要执行的任务批量放入任务队列，然后在启动多个线程来执行这些任务，从而提高了工作效率，这样做的好处是显而易见，线程池中线程是可以重复使用的，避免了频繁的创建和销毁线程而带来的系统开销， 我们知道在Java编程中，默认情况下一个进程都会对应着一个线程，而这个线程就是主线程，这个主线程就是我们Android开发中对应的UI主线程ActivityThread。

Android中的UI主线程主要是用来运行四大组件以及处理他们和界面的交互逻辑，同时UI主线程也是一个Loop线程，一般情况下，当程序执行完毕就会自动退出了，我们打开一个Activity界面的时候，当Activity生命周期的各个回调都执行完毕的时候，Activity界面并没有销毁，界面依然在我们面前，这说明此时应用程序依然是在存活运行的，这就是Loop循环器在起作用，它是一个非阻塞式的死循环。UI主线程之外的其他线程都是子线程，子线程主要完成一些比较耗时的操作，这些耗时的操作完成之后会通过主线程的Handler发送消息来更新UI界面。

以上就是Android操作系统中关于线程的一些基本理论和概念，Android应用框架层也给我们提供了一些关于线程和线程池的API，如HandlerThread，IntentService，AsyncTask，下面我们就逐一介绍他们的使用方法和工作原理。

HandlerThread的使用

HandlerThread是Android给我们提供的一个异步消息处理线程，现在我们看看他的简单使用，首先创建一个HandlerThread，如下所示：

HandlerThread handlerThread = new HandlerThread("handler-thread");
handlerThread.start();

紧接着通过HandlerThread对象的loop构建一个Handler，具体实现如下：

Handler handler = new Handler(handlerThread.getLooper()){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
                Log.v("MYTAG","handleMessage what:"+msg.what+";currThread:"+Thread.currentThread().getName());
            }
        };

拿到handlerThread的loop对象，把它传递给Hanlder的构造方法创建了一个Handler对象，并复写它的handleMessage方法来接收消息，最后一步就是发送消息了，如下所示：

handler.sendEmptyMessage(0);
handler.sendEmptyMessage(1);

发送了两个空消息，看看打印日志：

2019-11-25 15:48:58.398 16338-16426/com.mxdl.customview V/MYTAG: handleMessage what:0;currThread:handler-thread
2019-11-25 15:48:58.398 16338-16426/com.mxdl.customview V/MYTAG: handleMessage what:1;currThread:handler-thread

通过日志我们可以知道handlerMessage方法是在子线程中执行的。以上就是HandlerThread的简单使用，接下来我们看看他的工作原理。

HandlerThread的工作原理

public class HandlerThread extends Thread

HandlerThread 继承了Thread，它本质上是一个Therad，但是他与普通的Thread又有所不同，主要表现在他的run方法，该方法如下所示：

@Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();//注释1
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();//注释2
        mTid = -1;
    }    

首先在注释1处调用Loop对象的prepare方法创建了一个Lopper对象，还创建了一个Looper所对应的消息队列，prepare方法具体代码实现如下：

    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));//注释3
    }
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);//注释4
        mThread = Thread.currentThread();
    }

Looper对象的prepare方法经过了一次重载调用实例化一个Looper对象如注释3所示，紧接着会在注释4处创建一个消息队列。然后我们在看注释2处调用了Looper对象的loop方法，这个方法是一个死循环，如果消息队列有消息它就会取取消息，如果没有就会一直阻塞在这里，此时一个异步消息处理线程就准备就绪了。最后通过HandlerThread 对象的Looper对象作为参数，来构建一个Handler对象，然后就可以通过Handler对象就可以给子线程发消息了，Handler的handlerMessage方法接受到消息后就可以做一些耗时的操作了，注意了，由于Handler发送的每一个消息都进入消息队列了，所以handlerMessage方法也是排队响应的。

最后还要注意一下，由于这个线程是一个死循环，所以在耗时任务执行完毕，需要手动的退出循环处理器，即需要调用HandlerThread的quit方法或者quitSafely方法退出循环，二者的区别在于quit会立即退出，quitSafely会等待消息队列中的所有消息都处理完毕才会退出。

IntentService的使用

IntentService是一个特殊的Service，我们知道Service它在前台不可见，它可以处理一些比较耗时的操作，但是在默认情况下Service里面的操作都是在UI主线程中完成的，如果有一些耗时的操作，还得自己启动一个线程来完成，其实这一切都可以通过IntentService来完成，从而简化了我们的操作，它封装了HandlerThread和Handler，使这一切都变得那么简单。

首先我们看一下他的简单使用，首先继承IntentService创建它的一个子类MyIntentService ，并复写它的onHandleIntent方法，在它里面可以做一些耗时的操作，实现如下：

public class MyIntentService extends IntentService {

    public MyIntentService() {
        super("MyIntentService");
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        Log.v("MYTAG","onHandleIntent currThread:"+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

然后启动服务，执行耗时操作：

startService(new Intent(this, MyIntentService.class));
startService(new Intent(this, MyIntentService.class));
startService(new Intent(this, MyIntentService.class));

打印日志如下：

2019-11-25 17:03:17.295 19107-19155 V/MYTAG: onHandleIntent currThread:IntentService[MyIntentService]
2019-11-25 17:03:20.298 19107-19155 V/MYTAG: onHandleIntent currThread:IntentService[MyIntentService]
2019-11-25 17:03:23.299 19107-19155 V/MYTAG: onHandleIntent currThread:IntentService[MyIntentService]

以上就是IntentService的简单使用，下面我们看看他的工作原理。

IntentService的工作原理

Service在启动的时候首先会执行它的onCreate方法，下面我们看看IntentService的onCreate方法的具体实现：

public abstract class IntentService extends Service {
 ...
 @Override
    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        //注释1
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        
        mServiceLooper = thread.getLooper();
        //注释2
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    ...

在onCreate方法中，创建了一个HandlerThread对象和一个Handler对象， 开启了一个异步消息处理线程，onCreate执行完毕之后就会调用startCommand方法，该方法的实现如下所示：

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

在onStartCommand方法的第一行会调用onStart方法，在onStart方法中向工作线程的消息管理器发送了一个消息，我们看看是怎么处理这个消息的，如下所示：

 private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);//注释1
        }
    }

在ServiceHandler的handleMessage方法接收到消息之后就会调用onHandleIntent方法执行耗时任务，执行完毕这个后台服务就停止了，在注释1的这个地方需要注意一下，如果直接调用不带参数的stopSelf那么服务就会立即停止，调用了带参数的stopSelf(int startId)方法，就会等待任务队列里面的所有任务都执行完毕它才会停止服务。

IntentService内部封装了HandlerThread和Handler，通过他可以执行一些耗时的操作，提高了进程的优先级，避免了了进程被系统杀死的可能性。

AsyncTask的使用

下面我们看看官方文档对它的权威定义：

在这里插入图片描述

这段话的主要意思是讲，AsyncTask在UI线程中使用是很方便的，它允许执行一个后台任务并发结果发送给UI主线程而不需要显示的去操作Thread和Hanlder，AsyncTask它被设计为一个帮助类，它围绕着Thread和Handler，它不构成一个通用的线程框架，AsyncTask适合做一些不是很耗时的操作，如果需要任务非常耗时则需要借助java.util包所给我们提供专业的多线程操作API,例如Executor, ThreadPoolExecutor and FutureTask。AsyncTask中定义了三个泛型参数，Params表示任务参数输入，Progress表示后台任务执行过程中发布的进度单元，Result表示执行结果。AsyncTask在工作过程中有四个回调方法，如下所示：

• onPreExecute() 在任务执行前做一些准备工作，在UI线程中调用
• doInBackground()后台任务执行的核心方法，在子线程中被执行
• onProgressUpdate()任务执行过程中进行更新进度的一些操作，在UI线程中被调用
• onPostExecute()当任务被执行完毕会调用该方法，在UI线程中被调用

下面我们自定义一个AsyncTask，直接继承AsyncTask即可，并明确指定Params, Progress, Result三个泛型参数的类型，复写它的doInBackground方法和onPostExecute方法，如下所示：

public class MyAsyncTask extends AsyncTask<String,Integer,String> {
    public String taskName;

    public MyAsyncTask(String taskName) {
        super();
        this.taskName = taskName;
    }

    @Override
    protected String doInBackground(String... strings) {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return taskName;
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        Log.e("MYTAG", "result:"+result);
    }
}

定义完毕就可以调用了，实现如下所示：

  new MyAsyncTask("AsyncTask1").execute("");
  new MyAsyncTask("AsyncTask2").execute("");
  new MyAsyncTask("AsyncTask3").execute("");

下面看看，打印日志如下：

2019-11-25 18:25:57.245 22060-22060 E/MYTAG: result:AsyncTask1
2019-11-25 18:26:00.286 22060-22060 E/MYTAG: result:AsyncTask2
2019-11-25 18:26:03.288 22060-22060 E/MYTAG: result:AsyncTask3

为了验证所有的异步任务时串行执行的还是并行执行的，我们在doInBackground方法中让子线程中睡眠3秒钟，通过测试我们发现任务时串行执行的，其实我们可以调用AsyncTask的executeOnExecutor方法实现并行执行，具体并行调用如下所示：

  new MyAsyncTask("AsyncTask1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  new MyAsyncTask("AsyncTask2").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  new MyAsyncTask("AsyncTask3").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");

调用是打印日志如下：

2019-11-25 18:23:11.958 21922-21922 E/MYTAG: result:AsyncTask2
2019-11-25 18:23:11.959 21922-21922 E/MYTAG: result:AsyncTask1
2019-11-25 18:23:14.970 21922-21922 E/MYTAG: result:AsyncTask3

通过日志中打印的时间，我们看到onPostExecute方法被被并发执行了，这样通过executeOnExecutor方法就简单的实现了任务的并行执行。

AsyncTask工作原理

以上就是AsyncTask的简单使用，下面我们看看的工作原理，从他的execute方法开始，该方法具体实现如下：

  @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

在execute方法中会紧接着会调用它的executeOnExecutor方法，该方法主要工作将传递过来的参数params交给WorkerRunnable保存起来，然后把具体的执行任务保存到任务队列当中，它的实现如下：

 @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
            switch (mStatus) {
                case RUNNING:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task is already running.");
                case FINISHED:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task has already been executed "
                            + "(a task can be executed only once)");
            }
        }

        mStatus = Status.RUNNING;
        //注释1
        onPreExecute();
        //注释2
        mWorker.mParams = params;
        //注释3
        exec.execute(mFuture);

        return this;
    }

在注释1处AsyncTask的第一个回调方法onPreExecute被执行了，紧着了在注释2处把传递过来的参数交给了WorkerRunnable，注释3处新来的任务进行入列操作，exec是SerialExecutor 类型的，它的execute方法具体的代码实现如下：

 private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            //注释1
            mTasks.offer(new Runnable() {
                //注释4
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                //注释2
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                //注释3
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

任务的入列具体会执行SerialExecutor对象的execute方法，在注释1处创建了一个新的任务把它存储到双端队列mTasks 当中，紧接着会在注释2处调用scheduleNext方法，这个方法的主要作用是从任务队列中取出任务并执行，具体实现为注释3，当任务开始执行的时候回调用注释4的run方法，在run方法的内部会回调传递过来的mFuture对象的run方法，执行完毕会继续调用scheduleNext方法进行下一个任务的执行，分析到这里我们也就不难得出结论，AsyncTask默认是串行执行的，即一个任务执行完毕，才能执行下一个任务。我们继续看，mFuture对象的类型是FutureTask，下面我们看他的run方法的实现：

 public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    //注释1
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

FutureTask的run方法在注释1处会调用Callable的call方法，而这个Callable就是我们前面在executeOnExecutor方法中所提到的mWorker对象，下面我们看mWorker对象的call方法的具体实现：

 mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    //注释1
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    //注释2
                    postResult(result);
                }
                return result;
            }
        };

在WorkerRunnable对象的call方法的注释1处AsyncTask的第二个方法doInBackground被调用了，它是执行异步任务的核心方法，在该方法的最后注释2处会调用postResult方法把执行的结果交给UI主线程，AsyncTask的postResult方法它的具体实现如下：

private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

postResultf方法通过Hanlder发送了一个MESSAGE_POST_RESULT类型的消息，此时任务的执行由工作子线程切换到了UI主线程，我们看Handler收到消息后是怎么处理的，具体代码实现如下：

private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    //注释1
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

Handler收到消息后，会在注释1处会执行AsyncTask对象的finish方法，它的具体实现如下：

 private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            //注释1
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

在注释1处我们清楚的看到AsyncTask的onPostExecute方法被回调了。截止目前AsyncTask的工作原理就分析完了，在AsyncTask的内部有两个线程池，一个SerialExecutor负责任务的入列和出列操作，另外一个是ThreadPoolExecutor负责具体的任务的执行，它的构建是在AsyncTask的静态代码块中完成的，具体的实现如下：

    private static final int CORE_POOL_SIZE = 1;
    private static final int MAXIMUM_POOL_SIZE = 20;
    private static final int BACKUP_POOL_SIZE = 5;
    private static final int KEEP_ALIVE_SECONDS = 3;

    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());
        }
    };  
    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(), sThreadFactory);
        threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

以上为Android10.0中AsyncTask的中的线程池THREAD_POOL_EXECUTOR的详细配置参数，和以前的版本可能有些差异，我们就以最新版本为主，通过代码我们不难发现，线程池中有一个核心线程，最大线程数为20，线程在空闲状态下的超时时长为3秒，线程池中的任务队列使用SynchronousQueue实现的。

总结

以上就Android系统中线程形态的具体三个表现形式，HandlerThread、IntentService和AsyncTask，HandlerThread是一个异步消息处理线程，IntentService是一个后台服务线程，AsyncTask是一个便于在子线程中访问UI线程的一个线程池，他们的底层实现都是Thread，但是他们都有自己特殊的使用场景，都是为了简化对线程的操作。通过这篇文章的学习，想必大家对Android系统应用层中的线程和线程池的操作有了更深刻的见解认知。