AsyncTask源码完全解析

Posted on

AsyncTask 源码分析

参考：https://blog.csdn.net/iispring/article/details/50670388

AsyncTask 使用流程

https://blog.csdn.net/carson_ho/article/details/79314325

图源：https://blog.csdn.net/carson_ho/article/details/79314326

开始准备工作

execute()

1
2
3
4
5
6
7
@MainThread

public final AsyncTask<Params, Progress, Result> execute(Params... params) {

     return executeOnExecutor(sDefaultExecutor, params);

 }

  • execute()只能在主线程执行

  • 调用executeOnExecutor方法，将sDefaultExecutor当作参数传入方法，这个是默认的执行的Executer

看一下sDefaultExecutor是个什么东西

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//sDefaultExecutor初始值是SerialExecutor的实例化
    private static class SerialExecutor implements Executor {
        //mTasks是一个维护Runnable 的双端队列，没有容量限制，其容量自增加，不支持并发
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        *//mActive表示正在执行的任务*
	    Runnable mActive;
        public synchronized void execute(final Runnable r) {
            *//将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的用处

  • 将执行任务进行进一步的封装，真正处理这个任务的是THREAD_POOL_EXECUTOR

  • 将新任务放进一个队列中，保证每次处理的都是按顺序的，也就是所谓的串行处理

  • 用THREAD_POOL_EXECUTOR线程池来进行任务的调度。

execteOnExecutor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
    @MainThread

​    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,

​            Params... params) {

​        if (mStatus != Status.PENDING) {

​            switch (mStatus) {

​                case RUNNING:

​                *//如果当前的AsyncTask是运行状态就抛出异常，不再执行新的任务*

​                    throw new IllegalStateException("Cannot execute task:"

​                            \+ " the task is already running.");

​                case FINISHED:

​                *//如果当前的AsyncTask是已完成状态也抛出异常，不再执行新任务*

​                    throw new IllegalStateException("Cannot execute task:"

​                            \+ " the task has already been executed "

​                            \+ "(a task can be executed only once)");

​            }

​        }



​        mStatus = Status.RUNNING;



​        onPreExecute();

​        *//将参数传递给mWorker*

​        mWorker.mParams = params;

​        exec.execute(mFuture);



​        return this;

​    }

将所有的处理任务所需要的信息，和对结果的控制放在mFuture里面，由线程池来调度任务的执行

  • onPreExecute();
1
2
3
4
5
6
7
//在真正开始执行之前先进行onPreExecute，重写此方法*

​    @MainThread

​    protected void onPreExecute() {

​    }
  • mWorker 是一个WorkerRunnable的对象
1
2
3
4
5
6
7
//指定泛型result的Callable*

​     private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {

​        Params[] mParams;

​    }

实际任务的处理

AsynaTask的构造函数，将mWorker和mFuture实例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
    *//AsyncTask的构造函数需要在ui线程调用*

​    public AsyncTask(@Nullable Looper callbackLooper) {

​        *//默认的主线程调用构造方法，如果不是主线程就创建一个这个looper的handler*

​        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()

​            ? getMainHandler()

​            : new Handler(callbackLooper);



​        mWorker = new WorkerRunnable<Params, Result>() {

​            public Result call() throws Exception {

​                *//mTaskInvoked 是一个可以保证原子性的布尔值*

​                *//call执行的时候，设为true表示该任务开始执行*

​                mTaskInvoked.set(true);

​                Result result = null;

​                try {

​                    *//将call执行的线程，设置为后台线程级别*

​                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

​                    *//noinspection unchecked*

​                    *//调用doInBackground实际执行任务，将结果返回，`在工作线程执行方法`,该线程由执行这个回调方法的线程来控制*

​                    result = doInBackground(mParams);

​                    *//刷新等待指令*

​                    Binder.flushPendingCommands();

​                } catch (Throwable tr) {

​                    *//将mCancelled设置为true，进行 异常判断，是否完成当前任务*

​                    mCancelled.set(true);

​                    throw tr;

​                } finally {

​                    *//将结果传给postresult，postresult将结果发送到当前handler的消息队列中*

​                    postResult(result);

​                }

​                return result;

​            }

​        };



​        mFuture = new FutureTask<Result>(mWorker) {

​            @Override

​            protected void done() {*//任务完成或取消都会调用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);

​                }

​            }

​        };

​    }

<!–6–>

任务执行过程中和结束时的消息处理

利用postResult将result中的信息发送给InternalHandler来处理

1
2
3
4
5
6
7
8
9
10
11
   private void postResultIfNotInvoked(Result result) {

​        final boolean wasTaskInvoked = mTaskInvoked.get();

​        if (!wasTaskInvoked) {

​            postResult(result);

​        }

​    }
1
2
3
4
5
6
7
8
9
10
11
12
13
    private Result postResult(Result result) {

​        @SuppressWarnings("unchecked")

​        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,

​                new AsyncTaskResult<Result>(this, result));

​        message.sendToTarget();

​        return result;

​    }

只是将result和task的实例进行封装，没有实例方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    private static class AsyncTaskResult<Data> {

​        final AsyncTask mTask;

​        final Data[] mData;



​        AsyncTaskResult(AsyncTask task, Data... data) {

​            mTask = task;

​            mData = data;

​        }

​    }

  • InternalHandler是一个继承了Handler的内部类，重写了handleMessage方法

  • msg有两种

  • MESSAGE_POST_RESULT： 表示任务已经完成，调用finish方法来处理结果

  • MESSAGE_POST_PROGRESS： 表示阶段性完成，publishProgress()发送的msg，调用onProgressUpdate来显示进度条等操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 private static class InternalHandler extends Handler {

​        public InternalHandler(Looper looper) {

​            super(looper);

​        }



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

​            }

​        }

​    }

根据状态来处理，已取消或者已完成来分别处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    private void finish(Result result) {

​        if (isCancelled()) {

​            onCancelled(result);*//调用onCancelled（）方法，需要重写*

​        } else {

​            *//onPostExecute需要重写*

​            onPostExecute(result);

​        }

​        mStatus = Status.FINISHED;

​    }

总结

AsyncTask的执行流程：

  • 在主线程（可以不是主线程）调用execute()方法，传入param参数，以SerialExecutor的实例化对象sDefaultExecutor为参数调用executeOnExecutor(Executor exec, Params… params)来处理params

  • SerialExecutor是继承executor一个内部类，内部维护了一个任务队列，保证事务的串行执行，实际是在线程池THREAD_POOL_EXECUTOR的execte方法来处理的，处理的就是FutureTask的对象

  • 将doInBackground方法封装在mWorker的call()方法中，再把mWorker当参数实例化一个FutureTask的实例，由FutureTask来处理doInBackground中的异常

  • mFuture在执行过程中发生异常时，是通过调用postResultIfNotInvoked方法调用postResult()

  • 执行成功时直接调用postResult来finish()，finish()再调用重写的onPostExecute()来处理结果