线程的概念在编程中是很重要的，Android当然也不例外了。如果单纯以用途来讲的话，线程分为主线程和子线程，一般来说，耗时操作要放在子线程里去做，所以子线程又叫工作线程，与界面有关的事情要放在主线程里去做，所以主线程又叫UI线程。说起线程，大家可能都知道Thread，但是，除了这个这个之外，还是有很多可以扮演线程的角色的，比如底层用到线程池和Handler的AsyncTask、底层直接使用传统线程的IntentService和HandlerThread。今天就来了解下这三个吧。
AsyncTask
AsyncTask是一个底层封装了线程池和Handler的轻量级的异步任务的类。可以在后台执行耗时任务，完成后将结果传递给主线程中。极大的方便了线程的操作。但是，既然都说了是轻量级的了，当然是有很多限制的了。第一、它不能去执行特别耗时的任务，有人用AsyncTask来执行网络请求，其实这样是不好的，网络请求我觉的应该用线程池比较好的，很多网络库中也是这么做的。第二、AsyncTask必须在主线程中创建。第三、execute方法必须在UI线程中调用。第四、AsyncTask对象只能调用一次execute方法。为什么呢？最好的答案当然在源码中了。
分析源码首先要从入口处分析，然后选择性跳入.
@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;
}
/**
* Convenience version of {@link #execute(Object...)} for use with
* a simple Runnable object. See {@link #execute(Object[])} for more
* information on the order of execution.
*
* @see #execute(Object[])
* @see #executeOnExecutor(java.util.concurrent.Executor, Object[])
*/
@MainThread
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
那么，这个sDefaultExecutor又是什么东东呢？它呢？实际上是一个串行的线程池，同一个进程中的所有的AsyncTask都会在这个池子里排队执行，并且按发起任务的先后来排队。好吧，还是先看代码吧。
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();
}
}A
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
上面的代码可以看出它是怎样排队的，execute方法会把线程任务插入到mTasks的队尾，如果没有正在活动的AsyncTask，那么就会调用scheduleNext方法执行下一个任务，当任务执行完的时候也会调用scheduleNext方法执行下一个任务，由此可见，AsyncTask不是并行而是串行的。当然要想让它并行也是可以的, 调用executeOnExecutor方法就行了。其实我在看源码的时候还发现了AsyncTask内部是由两个线程池的，顺便看下。
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
public static final Executor THREAD_POOL_EXECUTOR;
/**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();```
其实注释已经写的很清楚了，前者是真正用来执行任务的，后者是用来排序的。
刚才说AsyncTask封装了线程池和Handler，那么Handler呢？别急，我们看看和handler相关的代码。
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
Result result = doInBackground(mParams);
Binder.flushPendingCommands();
return postResult(result);
}
};
这个方法位于构造方法里，我们看postResult(result)，很明显后台任务执行外后，要通过这个方法传递结果到主线程的，很容易想到与Handler有关系的。那么继续跟踪，
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
果然，这里见到了熟悉的代码，那么从哪里接受到的呢？Ctrl+F "MESSAGE_POST_RESULT"是很容易找到的。
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;
}
}
}
可以看到这是一个static的Handler，为了可以切换到主线程，要求InternalHandler对象要在主线程实例化，所以AsyncTask也要在主线程中创建。
#### HandlerThread
HandlerThread继承Thread 是一个特殊的Thread，可以实现Handler的Thread
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
上面的代码中可以看出，HandlerThread在其run方法里创建了一个消息队列，然后 Looper.loop()，开启消息循环。需要注意的是，这里 Looper.loop()开启的是一个无限的循环，因此，用完后记得终止线程，具体可以通过quit或者quitSafely ，quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。
#### IntentService
IntentService是一个特殊的Service，和Service一样，要想使用它必须创建它的子类。它可以执行后台耗时任务，而且优先级较高，不容易被杀死。它封装了HandlerThread和Handler
@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时都会调用onStart方法像mServiceHandler发送一个消息，消息会在HandlerThread中被处理。mServiceHandler收到消息最终会交给onHandleIntent处理。onHandleIntent执行结束后，IntentService会通过stopSelf(msg.arg1)来停止服务，这个方法会等待所有的消息都处理完才来终止服务。每执行一个任务就需要启动一次IntentService，IntentService内部是通过消息机制像HandlerThread请求执行任务的，而Handler中的Looper是顺序处理消息的，这意味着IntentService也是顺序执行后台任务的。