ActivityThread 与 AsyncTask

在开始这篇文章前，我们先来讨论以下几个问题

问题：

1. 子线程中可不可以像主线程一样具有消息循环？【子线程常驻】【prepare loop】
2. 主线程是如何往子线程中发消息的？【防止主线程阻塞】【HandlerThread】
   
3. 子线是如何往主线程发消息的？【更新UI】【HandlerThread】
4. HandlerThread的使用，AsyncTask的实现原理。
   

解答：

1.子线程中可不可以像主线程一样具有消息循环？

public final class ActivityThread {  // 新建一个类，使他常驻不退出
　　......
　　public static final void main(String[] args) { 
　　......
　　Looper.prepareMainLooper(); // 调用此方法，只有在主线程调用prepareMainLooper()函数，子线程只能用prepare()函数
　　......
　　ActivityThread thread = new ActivityThread();
　　thread.attach(false);
　　......
　　Looper.loop();   // 进入loop
　　......
　　thread.detach();
　　......
　　}
　　......
}

// 通过以上prepareMainLooper()或者prepare()函数与loop()函数的调用即可保证main()方法常驻不退出

// 接下来看一下prepareMainLooper()或者prepare()的异同

public class Looper {
　　......
　　// sThreadLocal.get() will return null unless you've called prepare().
　　private static final ThreadLocal sThreadLocal = new ThreadLocal();
　　public static final void prepare() { // 保证sThreadLocal中只有一个Looper，在子线程中调用
　　if (sThreadLocal.get() != null) {
　　 throw new RuntimeException("Only one Looper may be created perthread");
　　}
　　sThreadLocal.set(new Looper());
　　}
　......
　　public static final Looper myLooper() {//获取sThreadLocal中的Looper
　　 return (Looper)sThreadLocal.get();
　　}
　　......
　　public static final void prepareMainLooper() {  // 在主线程中调用
　　prepare();//先调用prepare，然后设置mMainLooper
　　setMainLooper(myLooper());
　　......
　　}
　　......
　　private static Looper mMainLooper = null;//主线程的looper
　　......
　　private synchronized static void setMainLooper(Looper looper) {
　　 mMainLooper = looper;
　　}
　　public synchronized static final Looper getMainLooper() {
　　 return mMainLooper;
　　}
　　......
}

2.主线程是如何往子线程中发消息的

// HandlerThread 的实现

public class HandlerThread extends Thread {

　　......
　　private Looper mLooper;
　　public HandlerThread(String name) {
　　super(name);
　　......
　　}
　　......
　　public void run() {
　　......
　　Looper.prepare();//注意此处是子线程，只有在子线程中才使用prepare()
　　synchronized (this) {
　　mLooper = Looper.myLooper();//子线程的mLooper实例化
　　......
　　 }
　　 ......
　　 Looper.loop();
　　 ......
　　}
　　public Looper getLooper() {
　　......
　　return mLooper;
　　}
　　......
}


　　// 此处是android源码中 加载APPS 的过程，子线是如何往主线程发消息的
　　public class LauncherModel extends BroadcastReceiver {
　　......
　　private LoaderTask mLoaderTask;
　　private static final HandlerThread sWorkerThread = new HandlerThread("launcher-loader");//创建一个HandlerThread线程
　　static {
　　 sWorkerThread.start();//启动HandlerThread线程
　　}

//用HandlerThread线程的Looper创建一个Handler,即这个handler即可往HandlerThread中发消息
　　private static final Handler sWorker = new Handler(sWorkerThread.getLooper());
　　......
　　public void startLoader(Context context, boolean isLaunching) {
　　......
　　synchronized (mLock) {
　　......
　　// Don't bother to start the thread if we know it's not going to do anything
　　if (mCallbacks != null && mCallbacks.get() != null) {
　　......
　　mLoaderTask = new LoaderTask(context, isLaunching);//创建一个线程mLoaderTask
　　sWorker.post(mLoaderTask);//往子线程中发一个消息，将线程mLoaderTask放入到子线程中去执行
　　}
　　}
　　}
　　......
　　private class LoaderTask implements Runnable {//定义一个线程类
　　......
　　public void run() {
　　......
　　keep_running: {
　　......
　　// second step
　　if (loadWorkspaceFirst) {
　　 ......
　　 loadAndBindAllApps();//加载全部apk
　} else {
　 ......
　}
　　......
　}
　......
　　}
　　......
　　}
　　......
}

3.AsyncTask的实现原理

public abstract class AsyncTask {

　　......
　　private static final BlockingQueue sWorkQueue = new LinkedBlockingQueue(10);//工作任务队列
　　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());//创建线程
　　}
　　};
　　//创建线程池sExecutor,核心线程数CORE_POOL_SIZE,最大线程数MAXIMUM_POOL_SIZE
　　//当线程池中线程数大于核心线程数时 空闲时间超过KEEP_ALIVE的线程将被回收, 

　　//KEEP_ALIVE的单位TimeUnit.SECONDS, 工作任务队列sWorkQueue, 线程工厂sThreadFactory
　　private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, 

MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

　　//创建三种消息以及创建一个主线程的Handler对象
　　private static final int MESSAGE_POST_RESULT = 0x1;
　　private static final int MESSAGE_POST_PROGRESS = 0x2;
　　private static final int MESSAGE_POST_CANCEL = 0x3;
　　private static final InternalHandler sHandler = new InternalHandler();

　　private final WorkerRunnable mWorker;
　　private final FutureTask mFuture;//构造时需要用到WorkerRunnable对象,执行时会调用WorkerRunnable对象的call函数，执行完后会调用done函数
　　......

　　public AsyncTask() {
　　 //实例化mWorker对象【Callable的子类WorkerRunnable的对象】
　　mWorker = new WorkerRunnable() {
　　public Result call() throws Exception {//回调函数中调用doInBackground(mParams) 
　　......
　　return doInBackground(mParams);//mParams是从AsyncTask对象的execute函数传进来的参数列表
　　}
　　};
　　 //实例化mFuture对象【Runnable的子类FutureTask的对象】 可以作为一个任务来运行
　　 mFuture = new FutureTask(mWorker) {//传入mWorker对象
　　 @Override
　　 protected void done() {//mWorker执行完成后会调用done方法??????
　　Message message;
　　Result result = null;
　　try {
　　 result = get();
　　} catch (InterruptedException e) {
　　 android.util.Log.w(LOG_TAG, e);
　　} catch (ExecutionException e) {
　　throw new RuntimeException("An error occured while executing doInBackground()",
　　e.getCause());
　　} catch (CancellationException e) {
　　message = sHandler.obtainMessage(MESSAGE_POST_CANCEL, new AsyncTaskResult(AsyncTask.this, (Result[]) null));
　　message.sendToTarget();
　　return;
　　} catch (Throwable t) {
　　throw new RuntimeException("An error occured while executing " + "doInBackground()", t);
　　}
　　//将运行结果AsyncTaskResult封装为Message对象，然后通过消息处理器sHandler加入到主线程的消息队列中
　　message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult(AsyncTask.this, result));
　　message.sendToTarget();
　　 }
　　};
　　}
　　......
　　public final Result get() throws InterruptedException, ExecutionException {
　　 return mFuture.get();
　　}
　　......
　　public final AsyncTask execute(Params... params) {
　　......
　　mWorker.mParams = params;//保存execute函数传入的参数列表
　　sExecutor.execute(mFuture);//执行子线程任务mFuture
　　return this;
　　}


　　......
　　protected final void publishProgress(Progress... values) {//在doInBackground中调用这个函数，则可以将values封装为消息发送到主线程队列里面。
　　 sHandler.obtainMessage(MESSAGE_POST_PROGRESS,new AsyncTaskResult(this, values)).sendToTarget();
　}


　private void finish(Result result) {
　　......
　　onPostExecute(result);
　　......
　　}
　　......


　　private static class InternalHandler extends Handler {
　　@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]);//将会调用onPostExecute函数
　break;
　case MESSAGE_POST_PROGRESS://处理publishProgress函数传递过来的值
　　result.mTask.onProgressUpdate(result.mData);
　　break;
　case MESSAGE_POST_CANCEL:
　　result.mTask.onCancelled();
　　break;
　}
　}
}

private static abstract class WorkerRunnable implements Callable {
　Params[] mParams; //用于保存从AsyncTask对象的execute函数传进来的参数列表
}

private static class AsyncTaskResult {
　final AsyncTask mTask;//创建的AsyncTask的对象
　final Data[] mData;//任务执行的结果
　AsyncTaskResult(AsyncTask task, Data... data) {
　mTask = task;
　mData = data;
　}
　　}
}