多线程开发---AsyncTask源码解析

在android开发中线程有主副之别,即耗时操作要由子线程操作,然后主线程来更新Ui;handler就充当一个子线程和主线程切换的角色;但是相比于handler,AsyncTask更加轻量级;那么直接开始解析AsyncTask的源码:

1.AsyncTask的使用:

        //参一:Params, 参二:Progress, 参三:Result
        AsyncTask mAsync = new AsyncTask<String,Integer,String>(){
            //在开始之前完成初始化等一系列的准备工作
            @Override
            protected void onPreExecute() {
                super.onPreExecute();
            }


            //在这个方法中处理耗时操作
            @Override
            protected String doInBackground(String... strings) {
                return null;
            }

            //接收处理完的返回值然后开始在UI线程中处理更新Ui的操作
            @Override
            protected void onPostExecute(String s) {
                super.onPostExecute(s);
            }

            //在这里跟新进度条
            @Override
            protected void onProgressUpdate(Integer... values) {
                super.onProgressUpdate(values);
            }
        }.execute(new String[]{"haha"} );

首先来看在new AsyncTask的时候 传入的参数为(Paramas,Progress,Result);在这一步就确定了 耗时操作参数的类型,耗时操作完成之后的返回值类型,进度条progress值的类型

2.execute(Params… params)

    首先来看execute源码:

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

看的出来execute的真正实现方法是:executeOnExecutor,ok~接下来来看executeOnExecutor的具体实现:

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

在以上源码中,第一步是走的AsyncTask的onPreExecute();相当于数据初始化的准备工作;
之后是mWorker.mParams = params;很明显是个mWorker的mParams属性赋值;ok~ 那么接着来看mWork(WorkerRunnable)这个类的源码实现:

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

以上代码看不出什么 那么据需看mWorker的具体实例化过程(即是new 该对象的过程):

    public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                     Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

注意关键代码:result = doInBackground(mParams);在这里mWorker.Params已经赋值完毕;然后params的值赋值给doInBackground的参数;供开发者来实现,以params作为参数来做耗时处理,最后返回result;
接着回到executeOnExecutor方法中 :onPreExecute()—>oWorker.Pramas = pramas;接着来看:exec.execute(mFueture);
那么我们来看mFueture所代表的类实例化的源码:

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

    首先会走FutureTask的构造,将参数mWorker进行初始化的赋值:

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    在走完构造之后Future中的run()也会走到,不放来看一下:

```
public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

这里的callable就是穿进来的参数mworker,然后调用mWorker的call方法返回耗时操作(供开发者实现并返回)的返回值,进行set(result)到线程池中(有兴趣要看下线程池的概念,这里先不解释)

这里写代码片

    ok~来看下new FutureTask<Result>(mWorker)关键的代码:

        postResultIfNotInvoked(get());

    先来看get()的实现:

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }


@SuppressWarnings("unchecked")
    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }

可以看出来get()—>reprot(s) 而report返回是(V)x,就是outcome;
然后追溯outcome:
看到outcome在set(Result)中被赋值;

protected void set(V v) {
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            outcome = v;
            U.putOrderedInt(this, STATE, NORMAL); // final state
            finishCompletion();
        }
    }

联系前面FutureTask实例化run()中通过set(result)到线程池,get()就是从先前的线程池中取出result;是不是恍然大悟;ok~这样我们就可以将:postResultIfNotInvoked(get());变化为postResultIfNotInvked(result)了;那么接下来看postResultIfNoInvoked的源码:

private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

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

很明显是要利用handler将result回归主线程更新ui,顺着猜测往下看,来追溯,handleMessger()的方法:

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

迅速找到刚刚发送msg的what为MESSAGE_POST_RESULT;ok~接下来就简单了 获取result作为参数走到 result.mTask.finish(result.mData[0]);
那么来看finish的源码:

    private void finish(Result result) {
        if (isCancelled()) result = null;
        // 在主线程中调用更新界面的方法
        onPostExecute(result);
        mStatus = Status.FINISHED;
    }

显而易见,在finish中调用onPostExecute(result)来更新ui(开发者实现抽象方法onPostExecute(result)来更新ui)

到这里AsyncTask的源码解析就完成了,感谢阅读,期待一起进步,欢迎关注,谢谢~