AsyncTask底层实现

AsyncTask底层实现

1.了解AsyncTask

onPreExecute() ：任务执行之前，做一些准备工作，运行于主线程，比如弹出一个进度条

doInBackground(Params…)：异步任务开始在这里执行，运行与子线程

progressUpdate（Progress）：主动调用，用于更新进度

onProgressUpdate(Progress…)：显示任务执行的进度，运行于主线程

onPostExecute（Result）：异步任务执行完毕，调用，运行于主线程

onCancel（）：调用cancel（）取消时，会回调该方法

2.源码解析

观看顺序：构造器->调用的地方execute()->调用逻辑

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

    mFuture = new FutureTask<Result>(mWorker) {
        @Override
        protected void done() {
            try {
                postResultIfNotInvoked(get());
            } catch (InterruptedException e) {
                android.util.Log.w(LOG_TAG, e);
            } catch (ExecutionException e) {
                throw new RuntimeException("An error occurred while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

构造器中初始化了一个WorkerRunnable（mWorker）和FutureTask(mFuture)对象，来看看mWorker

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}

可以看出，其实是一个实现了Callable的抽象类，里面是我们传入的参数AsyncTask<Params,...>

接下来看一下execute()方法

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

里面调用了executeOnExecutor()方法，首先看一下sDefaultExecutor

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

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

数组队列mTasks调用offer()方法，在末尾插入了一个Runnable对象，在try中调用了参数r.run()，在finally中调用了scheduleNext（）方法，第一次调用execute()方法,mActive为null，所以会调用scheduleNext()方法，

public static final Executor THREAD_POOL_EXECUTOR
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

THREAD_POLL_EXECUTOR是一个线程池，调用它的execute()方法，线程正式开始执行

让我们回到构造方法

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

    mFuture = new FutureTask<Result>(mWorker) {
        @Override
        protected void done() {
            try {
                postResultIfNotInvoked(get());
            } catch (InterruptedException e) {
                android.util.Log.w(LOG_TAG, e);
            } catch (ExecutionException e) {
                throw new RuntimeException("An error occurred while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

线程开始执行，会调用call()方法，接着

private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

mTaskInvoked.set(true);

然后调用doInBackgound()，开始处理子线程的任务，当执行完毕，调用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()获取内部的一个Handler对象

private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return 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;
        }
    }
}

message.sendToTarget()是Message的一个方法

public void sendToTarget() {
    target.sendMessage(this);
}

target是一个Message内部的Handler对象，其实指的是InternalHanlder

接着看InternalHanlder中的handleMessage（）方法

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

doInBackground（）方法执行完毕，发送了MESSAGE_POST_RESULT的消息，然后handler收到就会调用handleMessage（）方法，走到result.mTask.finish()方法，看一下AsyncTaskResult

private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;

    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}

可以知道，msg.obj是一个AsyncTaskResult对象

result.mTask.finish()其实调用的就是该AsyncTask的finish（）方法

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

看一下isCancelled

public final boolean isCancelled() {
    return mCancelled.get();
}

private final AtomicBoolean mCancelled = new AtomicBoolean();

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

如果主动调用AsyncTask的cancle()方法，那么mCancelled就置为true，所以在finish（）中会走onCancel（）方法，否则调用onpostExecute（）

@MainThread
protected void onPostExecute(Result result) {
}

接着看publishProgress（Progress），主要在doInBackground（）中，用于更新进度等

@WorkerThread
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

之后会调用handleMessage中的onProgressUpdate（）

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

整个过程就比较清楚了