AsyncTask中线程转换的实现

说明：最开始接触网络的时候，那时候尝试写了写回调，但自己写不出线程的转换来，就必须在回调方法中写上runOnUiThread方法来切换到主线程。最近研究了一下Android中的线程，一时冲动有了写博客的想法，来记录下自己的成长之路。

Android中一般采用Handler来实现主线程与子线程的切换，这是最常用的，就不再废话了，那么我们来看一下AsyncTask的实现。

AsyncTask的使用前提是，必须在主线程中创建AsyncTask的子类对象，那么这个前提正是可以获取主线程的基础。

private static InternalHandler sHandler;

这是AsyncTask里的一个静态成员变量，显然，它就是线程转换的关键类，下面是InternalHandler的源码

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

可以看到InternalHandler的构造方法中调用了Handler的Handler(Looper looper)这个构造方法，将主线程的looper传入，那么这个handler处理消息就会在looper的线程中执行。

继续来看Handler的源码

public Handler(Callback callback, boolean async) {        ......        mLooper = Looper.myLooper();        if (mLooper == null) {            throw new RuntimeException(                "Can't create handler inside thread that has not called Looper.prepare()");        }        mQueue = mLooper.mQueue;        mCallback = callback;        mAsynchronous = async;    }

这里也证明了如果在一个线程中没有执行Looper.prepare()方法，直接创建Handler是会抛出异常的，mLooper = Looper.myLooper(); 打开Looper的myLooper方法，来看源码

public static @Nullable Looper myLooper() {        return sThreadLocal.get();    }

可以看到Looper用一个ThreadLocal

Thread currentThread = Thread.currentThread();

其它代码不再贴出，但是到此我们可以看出Looper与创建Looper的线程是相联系的，我们使用Looper来从MessageQueue并交给Handler的HandleMessage来处理

回到主题
在AsyncTask中

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

可以看到在doPackground方法执行完成后会调用postResult方法并将结果传入，来看postResult方法

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

getHandler的实现

private static Handler getHandler() {        synchronized (AsyncTask.class) {            if (sHandler == null) {                sHandler = new InternalHandler();            }            return sHandler;        }    }

可以发现最终会有InternalHandler来执行发送消息的方法，因为InternalHandler肯定是主线程的Handler，那么最终处理消息肯定是在主线程中

来看InternalHandler的handleMessage方法的源码

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

由语义就可以看出一个是得到了结果，一个是更新进度
更新进度会调用onProgressUpdate方法，得到结果会调用result.mTask.finish(result.mData[0]);

下面是mTask.finish()方法的源码

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

可以看到如果任务被取消会调用onCancelled方法，否则执行onPostExecute方法

总结：AsyncTask之所以可以在主线程执行进度更新的方法和onPostExecute方法，关键的类就行内部维护了一个肯定在主线程的类InternalHandler，本质就是Handler，由这个类来执行onProgressUpdate与onPostExecute方法，那么就实现了线程的转换。