从源码角度理解Android线程

线程分为主线程和子线程，主线程主要是做与界面相关的事，而子线程往往用于做耗时操作。Android中扮演线程的角色有很多，如：AsyncTask、IntentService以及HandlerThread。AsyncTask的底层使用的是线程池，其他两种直接使用线程。

AsyncTask封装了线程池和Handler，在它的内部使用Handler去更新UI线程。HandlerThread是一个具有消息循环的线程。IntentService是一种服务，内部采用HandlerThread来执行任务，由于是一种服务，不是Service，所以不会轻易被系统杀死。

由于频繁的创建和销毁线程会消耗大量的系统资源，所以一般是用线程池来进行控制，Android的线程池源于Java。

一、主线程和子线程

主线程是进程拥有的线程，Java默认只有一个主线程，主线程主要处理界面交互的逻辑，必须有较高的响应度，不然会造成界面延缓卡顿，这就要求主线程不能执行耗时任务，耗时任务交由子线程，即工作线程。

Android沿用了Java的线程模式，其中主线程叫UI线程，作用是运行四大组件以及处理它们同用户交互，而子线程执行耗时的任务，否则会出现ANR现象。

---

二、Android的线程形态

除了传统的Thread以外，还包含AsyncTask、HandlerThread以及IntentService,这三者底层实现也是线程。

1.AsyncTask

AsyncTask是一个轻量级的异步任务类，他可以在线程池中执行后台任务，然后把任务的进度和最终的结果传递给主线程并在主线程中更新UI。AsyncTask封装了Thread和Handler，但是AsyncTask不适合执行特别耗时的任务，虽然说内部封装了线程池，但是该线程池只有一条线程。

AsyncTask是一个抽象的泛型类，它提供了Params、Progress、Result这三个泛型参数，其中Params表示参数的类型，Progress表示后台的执行任务的类型，Result表示后台任务的执行结果类型，如果不需要传入参数，可以使用void来代替。AsyncTask的声明如下：

• Params 启动任务执行的输入参数，比如HTTP请求的URL。
• Progress 后台任务执行的百分比。
• Result 后台执行任务最终返回的结果，比如String。

public abstract class AsyncTask<Params,Progress,Result>

AsyncTask提供了4个核心方法，含义如下：

• onPreExecute(): 在主线程中执行，在异步任务加载执行之前，此方法会调用，用于做一些任务准备工作。
• doInBackground(Params… params):在线程池中执行，此方法用于执行异步任务，params表示异步任务的输入参数。在此方法中可以通过publishProgress来更新任务进度，publishProgress会调用omProgressUpdate方法。另外此方法需要返回结果给onPostExecute方法。
• onProgressUpdate(Progress…values):在主线程中执行，当后台任务执行发生改变会调用此方法。
• onPostExecute(Result result):在主线程中执行，在异步任务执行的后面，其中result参数是后台任务的返回值，即doInBackground的返回值。

上面的几个方法，onPreExecute先执行，接着是doInBackground，最后是onPostExecute。此外，AsyncTask还提供了onCancelled方法，它在主线程中用，当异步任务被取消，就会调用该方法，这个时候onPostExecute就不会被调用。

    private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {        protected Long doInBackground(URL... urls) {            int count = urls.length;            long totalSize = 0;            for (int i = 0; i < count; i++) {                // totalSize += Downloader.downloadFile(urls[i]);                publishProgress((int) ((i / (float) count) * 100));                // Escape early if cancel() is called                if (isCancelled())                    break;            }            return totalSize;        }        protected void onProgressUpdate(Integer... progress) {            // setProgressPercent(progress[0]);        }        protected void onPostExecute(Long result) {            // showDialog("Downloaded " + result + " bytes");        }    }

该Demo主要模拟文件下载的过程，输入的参数类型是URL，后台任务的进程参数为Integer，而后台返回的结果是Long

new DownloadFilesTask().execute(new URL("http://www.baidu.com"),new URL("http://www.renyugang.cn"));

在DownloadFilesTask中，doInBackground用来执行具体的下载任务并通过publishProgress来更新下载的进度，同时要判断是否被外界取消。当下载完成后会调用onProgressUpdate来显示结果。doInBackground是在线程池中执行的，onProgressUpdate是在主线程中，当publishProgress被调用时，会顺带调用onProgressUpdate。当任务执行完毕后，也会调用onPostExecute，我们可以通过这个方法告知用户下载完毕。

AsyncTask在具体使用过程中也有一些限制，主要如下几点：

• (1)AsyncTask必须在主线程中加载，Android4.1以上的系统已经自动完成了，在ActivityThread的main方法中会调用AsyncTask的init方法。
• (2)AsyncTask的实例必须在主线程中创建
• (3)execute方法必须在UI线程中调用
• (4)不要在程序中手动调用onPreExecute、onPostExecute。doInBackground、onProgressUpdate方法。
• (5)一个AsyncTask对象只能执行一次，只能调用一次execute方法。
• (6)在Android 1.6之前，AsyncTask是串行执行任务，1.6后可以并行执行，但是3.0以后，为了避免并行带来的bug，又采用串行，虽然这样，但也可以通过AsyncTask的executeOnExecutor方法来并行执行任务。

2.AsyncTask的工作原理

分析AsyncTask的工作原理，我们从它的execute方法爱是分析，execute又会调用executeOnExecutor方法，实现如下：

    @MainThread    public final AsyncTask<Params, Progress, Result> execute(Params... params) {        return executeOnExecutor(sDefaultExecutor, params);    }        @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;        onPreExecute();        mWorker.mParams = params;        exec.execute(mFuture);        return this;    }

sDefaultExecutor实际上是一个串行的线程池，一个进程中所有的AsyncTask都在这个线程池中排队执行，在executeOnExecutor方法中，最先执行的是onPreExecute，然后线程池开始执行，下面试线程池的分析，如下所示：

    private static class SerialExecutor implements Executor {        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();        Runnable mActive;        public synchronized void execute(final Runnable r) {            mTasks.offer(new Runnable() {                public void run() {                    try {                        r.run();                    } finally {                        scheduleNext();                    }                }            });            if (mActive == null) {                scheduleNext();            }        }        protected synchronized void scheduleNext() {            if ((mActive = mTasks.poll()) != null) {                THREAD_POOL_EXECUTOR.execute(mActive);            }        }    }

从SerialExecutor的实现可以看出AsyncTask是排队执行的过程。首先会把AsyncTask的Params参数封转成FutureTask对象，FutureTask是并发类，在这里充当Runnable的作用，接着FutureTask交给SerialExecutor的execute方法执行，SerialExecutor的execute会通过mTask的offer将FutureTask对象插入到mTask中，如果这个时候没有正在活动的AsyncTask，或者当一个AsyncTask任务执行完，就会调用SerialExecutor的scheduleNext方法来执行下一个任务，直至任务被执行完毕。

AsyncTask中有两个线程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一个Handler(InternalHandler)，其中SerialExecutor用于任务的排队，THREAD_POOL_EXECUTOR用于真正的执行任务，InternalHandler用于将执行环境切换到主线程。AsyncTask的构造方法中有这么一段代码，由于FutureTask的run方法会调用mWorker的call方法，FutureTask会被提交到AsyncTask包含的线程池中执行，因此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                    result = doInBackground(mParams);                    Binder.flushPendingCommands();                } catch (Throwable tr) {                    mCancelled.set(true);                    throw tr;                } finally {                    postResult(result);                }                return result;            }        };

mWorker的call方法中，首先将mTaskInvoked标记位true，表示当前任务被执行过，然后执行AsyncTask的doInBackground方法，接着将返回值传给postResult方法，它的实现如下：

    private Result postResult(Result result) {        @SuppressWarnings("unchecked")        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,                new AsyncTaskResult<Result>(this, result));        message.sendToTarget();        return result;    }        private static Handler getHandler() {        synchronized (AsyncTask.class) {            if (sHandler == null) {                sHandler = new InternalHandler();            }            return sHandler;        }    }

在上面代码中，会通过getHandler返回一个sHandler，通过sHandler返回一个MESSAGE_POST_RESULT的消息，这个sHandler的定义如下：

    private static InternalHandler sHandler;    private static class InternalHandler extends Handler {        public InternalHandler() {            super(Looper.getMainLooper());        }        @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                    result.mTask.finish(result.mData[0]);                    break;                case MESSAGE_POST_PROGRESS:                    result.mTask.onProgressUpdate(result.mData);                    break;            }        }    }

sHandler是一个静态变量，为了能够将环境切换到主线程，必须要在主线程中创建sHandler，这就变相要求AsyncTask也需要在主线程中加载。sHandler收到MESSAGE_POST_RESULT这个消息后，会调用AsyncTask的finish的方法：

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

AdyncTask的finish方法逻辑比较简单，如果AsyncTask被执行了，那么onCancelled就被调用，否则就执行onPostExecute方法。

3.HandlerThread

HandlerThread继承了Thread，本质上是一个Thread，只不过内部建立了Looper，可以使用Handler，主要是在run方法中通过Looper.prepare()来创建消息队列，然后通过Lopper.loop()来开启消息循环，在实际应用中就允许在HandlerThread中创建Handler了。HandlerThread的run方法如下：

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

从HandlerThread的实现来看，HandlerThread内不能创建了消息队列，这和普通的Thread不一样，要通过Handler的消息方式通知HandlerThread去执行任务。在使用完HandlerThread后，可以通过quit或者quitSafety来退出。

4.IntentService

IntentService是一种特殊的Service，它继承Service并且是个抽象类，所以要用它的子类。IntentService是一种服务，所以优先级比单纯的线程高，里面封装了HandlerThread和Handler，这一点从他的onCreate方法可以看出。

    @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();        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");        thread.start();        mServiceLooper = thread.getLooper();        mServiceHandler = new ServiceHandler(mServiceLooper);    }

当IntentService第一次被启动的时候，它的onCreate会被调用，然后创建一个HandlerThread对象，用它的Looper来构建一个Handler对象，这样每次发送handler发送消息的时候都会在HandlerThread线程中执行。

每次启动IntentHandler，都会调用onStartCommand方法，IntentService在onStartCommand中处理每个后台任务的Intent，同时调用onStart方法：

    @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);    }

可以看出，IntentService仅仅通过mServiceHandler发送一个消息，这个消息会在HandlerThread中处理，mServiceHandler收到消息后，会将Intent对象传递到onHandlerIntent中去处理，这个Intent和一开始传进来的Intent是一样的。当onHandlerIntent方法执行结束后，IntentService会调用stopSelf(int startId)来停止服务，该方法会等消息队列没有消息后才停止，而stopSelf()会立即就停止。

    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);        }    }

InstentService的onHandleIntent方法是一个抽象方法，我们需要在子类中实现，它的作用是通过Intent参数中区分具体的任务并执行任务，执行完后通过stopSelf(int startId)来停止服务。另外，每次执行一个后台任务必须启动一次IntentHandler，而内部通过消息的方式向HandlerThread请求执行任务，HandlerThread的Looper是顺序执行任务，这就意味着IntentService也是顺序执行任务。