AsyncTask源码解析

优缺点:

优点
它封装了Handler,使创建异步任务变得更加简单,相较于Handler+Thread的模式,不再需要编写任务线程和Handler实例即可完成相同的任务。
缺点

  • 不适合长时间的后台操作(适合几秒钟的操作)
  • AsyncTask的生命周期没有跟Activity的生命周期同步
    AsyncTask不会随着activity的销毁而销毁,它会一直执行, 直到doInBackground()方法执行完毕。如果在Activity销毁之前,没有取消 AsyncTask,有可能让我们的AsyncTask崩溃(crash)。因为它在onPostExecute()中想要处理的view已经不存在了。所以,我们总是必须确保在销毁活动之前取消任务。
    另外,即使我们正确地调用了cancle() 也未必能真正地取消任务。因为如果在doInBackgroud里有一个不可中断的操作,比如BitmapFactory.decodeStream(),那么这个操作会继续下去。
  • 容易内存泄漏
    如果AsyncTask被声明为Activity的非静态的内部类,那么AsyncTask会保留一个对创建了AsyncTask的Activity的引用。如果Activity已经被销毁,AsyncTask的后台线程还在执行,它将继续在内存里保留这个引用,导致Activity无法被回收,引起内存泄露。
  • 结果丢失
    屏幕旋转或Activity在后台被系统杀掉等情况会导致Activity的重新创建,之前运行的AsyncTask会持有一个之前Activity的引用,这个引用已经无效,这时调用onPostExecute()再去更新界面将不再生效。

要注意的地方:

  • 并行还是串行
    在Android 1.6之前的版本,AsyncTask是串行的,在1.6至2.3的版本,改成了并行的。在2.3之后的版本又做了修改,可以支持并行和串行,当想要串行执行时,直接执行execute()方法,如果需要并行执行,则要执行executeOnExecutor(Executor)。
  • 在activity的destroy()中执行cancel()后,AsyncTask将执行完doInBackground(),但不再执行onPostExecute()和onProgressUpdate(),而是执行onCancelled().

使用:

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private ProgressDialog mDialog;
    private TextView mTextView;
    MyAsyncTask myAsyncTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.id_tv);
        mDialog = new ProgressDialog(this);
        mDialog.setMax(100);
        mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        mDialog.setCancelable(true);
        myAsyncTask = new MyAsyncTask();
        myAsyncTask.execute();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (myAsyncTask != null)
            myAsyncTask.cancel(true);
    }

    private class MyAsyncTask extends AsyncTask {

        @Override
        protected void onPreExecute() {
            mDialog.show();
            Log.e(TAG, Thread.currentThread().getName() + " onPreExecute ");
        }

        @Override
        protected Void doInBackground(Void... params) {

            // 模拟数据的加载,耗时的任务
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(80);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                publishProgress(i);
            }

            Log.e(TAG, Thread.currentThread().getName() + " doInBackground ");
            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            mDialog.setProgress(values[0]);
            Log.e(TAG, Thread.currentThread().getName() + " onProgressUpdate ");
        }

        @Override
        protected void onPostExecute(Void result) {
            // 进行数据加载完成后的UI操作
            mDialog.dismiss();
            mTextView.setText("LOAD DATA SUCCESS ");
            Log.e(TAG, Thread.currentThread().getName() + " onPostExecute ");
        }
    }
}

效果:


AsyncTask源码解析_第1张图片

源码分析:

好了,上述我们基本得到了AsyncTask的执行流程,现在我们通过源码并且结合上述案例,对AsyncTask做更为细致的分析:

一、 首先我们是在主线程上创建了一个继承AsyncTask的MyAsynTask类: MyAsynTask myAsynTask = new MyAsynTask();由于是继承关系,上述方法执行了MyAsynTask的父类AsyncTask的构造方法:

public AsyncTask() {
    mWorker = new WorkerRunnable() {
        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(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);
            }
        }
    };
}
  • AsyncTask类初始化了两个类:mWorker 与mFuture:
  • WorkerRunnable是实现了Callable接口的抽象方法;FutureTask实现了RunnableFuture,而RunnableFuture接口继承了Runnable和Future
private static abstract class WorkerRunnable implements Callable 

public interface RunnableFuture extends Runnable, Future
public class FutureTask implements RunnableFuture

二、 调用myAsynTask对象的execute()方法,并且传递参数huhx;我们跟进去,发现实际的执行是:executeOnExecutor(sDefaultExecutor, params);

public final AsyncTask 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;
}
  • 该方法首先是判断mStatus状态,如果是正在运行(RUNNING)或者已经结束运行(FINISHED),就会抛出异常。
  • 接着设置状态为运行,执行onPreExecute()方法,并把参数的值赋给mWorker.mParams;
  • 于是Executor去执行execute的方法,学过java多线程的都知道。这个方法是开启一个线程去执行mFuture中的run()方法
  • 注意mFuture和mWorker都是在AsyncTask的构造方法中初始化过的

三、根据上述讲解,将执行mFuture的run,也就是将执行mWorker的call方法,如下:

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);
}
  • 设置最高优先级,接着执行了doInBackground()方法,注意它的参数mParams正是mWorker的属性mParams,而我们在之前有过这样的代码:mWorker.mParams = params;因此doInBackground方法的参数就是execute方法传递的参数
  • 好了,执行到了我们重写的doInBackground()方法了,现在要回到MyAsynTask类中的来了,在doInBackground中执行了publishProgress方法。跟进去,我们看一下代码
protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult(this, values)).sendToTarget();
    }
}

四、 上述我们讲到了Handler的部分了,很自然的我们是不是要看一下Handler的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;
    }
}

由于上述传递的消息是MESSAGE_POST_PROGRESS,所以result.mTask.onProgressUpdate(result.mData);得到执行,那么result.mTas是什么了,对了,就是我们的AsyncTask。由于AsyncTaskResult的第二个参数是values是publishProgress的参数,那么onProgressUpdate中的参数就是publishProgress方法的参数,如下:

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

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

五、 好了,我们要回到第三步的,最后一个postResult(result)方法了,在这个方法当中,如下

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

看到没有,发送了MESSAGE_POST_RESULT信息,于是在第六步中的handleMessage方法的代码中result.mTask.finish(result.mData[0])得到执行,在这个方法中,执行了AsyncTask的finish方法

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

在这代码中,如果没有取消,那么就执行onPostExecute方法,记得result是什么吗?Result result = doInBackground(mParams);正是doInBackground方法返回的结果
最后将状态设置为Status.FINISHED,还记得我们在AsyncTask的简要说明的第四点说过吗?一个任务实例只能执行一次,如果执行第二次将会抛出异常,因为执行完一次之后,状态变成FINISHED,在executeOnExecutor方法中会有如下判断:会报异常的!

case FINISHED:
        throw new IllegalStateException("Cannot execute task:"
                + " the task has already been executed "
                + "(a task can be executed only once)");
}

六、对于在任务的取消中那些说明,我们额外去对它的源码做一些简单的分析:
调用onCancelled(true)时,系统会发送MESSAGE_POST_RESULT信息,也就是提前进入了上述第五步:执行如下代码

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

由于设置了onCancelled(true),所以onCancelled(result)方法得到执行。之后再设置状态为Status.FINISHED;

建议阅读

Java多线程:Executor,Executors,Future,Callable,Runnable等

参考

为什么Android AsyncTask的使用要遵循五大原则

你可能感兴趣的:(AsyncTask源码解析)