AsyncTask使用和源码解析

小虎牙007
183 阅读10分钟

开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第7天，点击查看活动详情

介绍

在Android中提起异步通信我们都会想到Handler。Android 除过使用Handler 进行异步任务外，AnsyncTask 也是Android原生就有的执行异步任务的关键类。

首先来看一下AsyncTask的基本用法，由于AsyncTask是-个抽象类，所以如果我们想使用它，就必须要创建一 个子类去继承它。在继承时我们可以为AsyncTask类指定三个泛型参数，这三个参数的用途如下:

  • Params :在执行AsyncTask时需要传入的参数，可用于在后台任务中使用。
  • Progress :后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。
  • Result:当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。

因此，一个最简单的自定义AsyncTask就可以写成如下方式:

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  
    ……  
}

这里我们把AsyncTask的第一个泛型参数指定为Void ，表示在执行AsyncTask的时候不需要传入参数给后台任 务。第二个泛型参数指定为Integer ，表示使用整型数据来作为进度显示单位。第三个泛型参数指定为Boolean ，则表示使用布尔型数据来反馈执行结果。

当然，目前我们自定义的DownloadTask还是一个空任务，并不能进行任何实际的操作，我们还需要去重写Async Task中的几个方法才能完成对任务的定制。经常需要去重写的方法有以下四个:

  • onPreExecute() 这个方法会在后台任务开始执行之间调用，用于进行一些界面上的初始化操作，比如显示一个进度条对 话框等。
  • doInBackground(Param...) 这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。任务一旦完成就 可以通过return语句来将任务的执行结果进行返回，如果AsyncTask的第三个泛型参数指定的是Void,就 可以不返回任务执行结果。注意，在这个方法中是不可以进行UI操作的，如果需要更新UI元素，比如说 反馈当前任务的执行进度，可 以调用publishProgress(Progre...)方法来完成。
  • onProgressUpdate(Progress...)当在后台任务中调用了publishProgress(Progres...)方法后，这个方法就很快会被调用，方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。
  • onPostExecute(Result) 当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数 传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进 度条对话框等。

执行线程

下边的日志是在AsyncTask 每个方法执行的日志输出:

10:39:23.899#[androidcode@]#7872#E#ThreadTask--> #onPreExecute thread is main
10:39:23.900#[androidcode@]#8130#E#ThreadTask--> #doInBackground thread is AsyncTask #2
10:39:23.931#[androidcode@]#7872#E#ThreadTask--> #onProgressUpdate thread is main
10:39:23.931#[androidcode@]#7872#E#ThreadTask-->

可以看到除过doInBackground方法外其他的方法都是在主线程中执行的。 为什么这里特意强调一下执行线程呢?因为耗时操作的处理是不能放在主线程中进行的，否则会有ANR 问题。 后面的对每个方法的源码分析的过程中会详细讲的为什么他们的线程是这样。

AsyncTask使用

因此，一个比较完整的自定义AsyncTask 就可以写成如下方式:

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {  
    @Override  
    protected void onPreExecute() {  
        progressDialog.show();  
    }
    @Override  
    protected Boolean doInBackground(Void... params) {  
        try {  
            while (true) {  
                int downloadPercent = doDownload();  
                publishProgress(downloadPercent);  
                if (downloadPercent >= 100) {  
                    break;  
                }  
            }  
        } catch (Exception e) {  
            return false;  
        }  
        return true;  
    }
    @Override  
    protected void onProgressUpdate(Integer... values) {  
        progressDialog.setMessage("当前下载进度：" + values[0] + "%");  
    }
    @Override  
    protected void onPostExecute(Boolean result) {  
        progressDialog.dismiss();  
        if (result) {  
            Toast.makeText(context, "下载成功", Toast.LENGTH_SHORT).show();  
        } else {  
            Toast.makeText(context, "下载失败", Toast.LENGTH_SHORT).show();  
        }  
    }  
}

这里我们模拟了一个下载任务，在doInBackground()方法中去执行具体的下载逻辑，在onProgressUpdate()方法中显示当前的下载进度，在onPostExecute()方法中来提示任务的执行结果。如果想要启动这个任务，只需要简单地调用以下代码即可:

new DownloadTask().execute();

以上就是AsyncTask的基本用法，怎么样，是不是感觉在子线程和Ul线程之间进行切换变得灵活了很多?我们并 不需求去考虑什么异步消息处理机制，也不需要专门使用一个Handler来发送和接收消息，只需要调用一下publi shProgres()方法就可以轻松地从子线程切换到UI线程了。

源码分析

构造方法

public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            //调用了doInBackground方法并将结果进行postResult
            return postResult(doInBackground(mParams));
        }
    };
    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 occured while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

初始化mWorker和mFuture，并在初始化mFuture的时候将mWorker作为参数传入。mWorker 是- -个Callable 对象，mFuture 是-一个FutureTask 对象，这两个变量会暂时保存在内存中，稍后才会用到它们。

启动某一任务

AsyncTask可以多线程异步，也可以单线程异常执行:

  • 并行
public static final Executor THREAD_POOL_EXECUTOR;
static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            sPoolWorkQueue, sThreadFactory);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
//指定Executor为AsyncTask.THREAD_POOL_EXECUTOR
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params);
  • 串行
private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
    public synchronized void execute(final Runnable r) {
        //调用ArrayDeque的offer()方法将传入的Runnable对象添加到队列的尾部
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    //链式调用执行mTasks中的Runnable
                    scheduleNext();
                }
            }
        });
        //第一次调用mActive为null，自己执行循环
        if (mActive == null) {
            scheduleNext();
        }
    }
    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            //使用THREAD_POOL_EXECUTOR去执行取出的取出的Runnable对象
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//execute默认是SerialExecutor，所以只有一个工作线程
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

onPreExecute的调用

AysncTask的调用非常简单，仅仅都是调用了executeOnExecutor方法:

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    //做检验，一个AsyncTask只能execute一次
    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执行task
    exec.execute(mFuture);
    return this;
}

onPreExecute方法是在进入线程池之前调用的，所以它内部的方法的执行线程等于调用executeOnExecutor方法的线程。

dolnBackground的调用

分析了这么多代码看到onPreExecute的调用那么接下来正真的任务执行方法实在哪里调用的呢? 上边分析的SerialExecutor的execute方法中，执行了Runnable的run方法，那么这个Runnable实例是什么呢?

executeOnExecutor方 法中的exec.execute(mFuture); 很明显Runnable的实例就是在AsyncTask初始化时声明的FutureTask。 我们来看看FutureTask的run方法:

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                //调用callable的call方法
                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);
    }
}

那么FutureTask 中的Callable 对象呢?就是我们在AsyncTask初始化中声明的WorkerRunable 。

mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception {
        mTaskInvoked.set(true);
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        //noinspection unchecked
        //doInBackground的执行结果抛到handle主线程
        return postResult(doInBackground(mParams));
    }
};

从这里看到doInBackground 方法是在线程池的线程中执行的。

onProgressUpdate方法的调用

如果我们需要调用onProgressUpdate 在AsyncTask执行的过程中对UI进行操作，那么只需要在doInBackground方法中调用publishProgress 方法，publishProgress 会将 中间值抛到handle主线程中。

之所以这样实现，是因为上面分析的doInBackground是在异步线程，如果需要更新UI那么必须切换到主线程执行。这里的线程切换用的是Handler

protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}
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:
                //onProgressUpdate的回调
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

onPostExecute方法的调用

上边讲述doInBackground方法的调用结束后会将结果传递给postResult方法。

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    //postResult的result结果抛到handle主线程
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}
private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;

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

而在InternalHandler中接受到MESSAGE_ _POST_ _RESULT消息执行了

private static class InternalHandler extends Handler {
  /*……*/
  result.mTask.finish(result.mData[0]);
  /*……*/
}

private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        //主线程将结果进行处理
        onPostExecute(result);
    }
    //状态改为结束
    mStatus = Status.FINISHED;
}

onPostExecute和onProgressUpdate 方法-样都是利用的Handler 做的线程切换，所以onPostExecute 方法内部逻辑也是在主线程执行的。

AsyncTask的cancel

取消AsyncTask的异步任务我们常用的方法是调用AsyncTask.cancel(true); 但这样真的结束我们正在执行的异步任务么?

//AysncTask.java
public final boolean cancel(boolean mayInterruptIfRunning) {
    //设置取消的原子状态
    mCancelled.set(true);
    //执行当前线程的interrupt
    return mFuture.cancel(mayInterruptIfRunning);
}

在FutureTask中我们对当前线程进行中断处理interrupt 。

。Thread.interrupt()方法不会中断一个正在运行的线程。 这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join,Threa d.sleep三种方法之一阻塞，那么，它将接收到一个中断异常(InterruptedException) ，从而提早地终结被阻塞状态。

//FutureTask.java
public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        finishCompletion();
    }
    return true;
}

所以尽管我们调用了cancel 给AsyncTask 设置了一个canceled的状态，那么想要终止异步任务，就需要在异步任务当中结束。

//判断是否被取消
public final boolean isCancelled() {
    return mCancelled.get();
}

AsyncTask内部的线程池//当前设备CPU核数

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();  
//核心线程池个数  
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;  
//线程池所能容纳的最大线程数，当活动的线程数达到这个值后，后续的新任务将会被阻塞。  
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;  
//控制线程闲置时的超时时长，超过则终止该线程。  
private static final int KEEP_ALIVE = 1;  
//线程池的任务队列，通过线程池的 execute(Runnable command) 方法会将任务 Runnable 存储在队列中(阻塞队列)。  
private static final BlockingQueue<Runnable> sPoolWorkQueue =  
//LinkedBlockingQueue一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于 ArrayBlockingQueue。  
//静态工厂方法Executors.newFixedThreadPool()使用了这个队列。  
new LinkedBlockingQueue<Runnable>(128);  
private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
private final AtomicInteger mCount = new AtomicInteger(1);  
  
public Thread newThread(Runnable r) {  
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());  
}  
};  
//用户线程池创建线程的工厂类  
private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
private final AtomicInteger mCount = new AtomicInteger(1);  
  
public Thread newThread(Runnable r) {  
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());  
}  
};  
public static final Executor THREAD_POOL_EXECUTOR  
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,  
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

AsyncTask版本间的差异

androidAPI(19)的时候AsyncTask中的线程池参数全是固定的。

//androidAPI=19  
private static final int CORE_POOL_SIZE = 5;  
private static final int MAXIMUM_POOL_SIZE = 128;  
private static final int KEEP_ALIVE = 1;  
  
private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
private final AtomicInteger mCount = new AtomicInteger(1);  
  
public Thread newThread(Runnable r) {  
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());  
}  
};  
  
private static final BlockingQueue<Runnable> sPoolWorkQueue =  
new LinkedBlockingQueue<Runnable>(10);  
  
/**  
* An {@link Executor} that can be used to execute tasks in parallel.  
*/  
public static final Executor THREAD_POOL_EXECUTOR  
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,  
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

Android 3.0之前是并没有SerialExecutor这个类，AsyncTask的执行 都是并行的。

//androidAPI=10  
public final AsyncTask<Params, Progress, Result> execute(Params... params) {  
if (mStatus != Status.PENDING) {123  
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;  
sExecutor.execute(mFuture);  
return this;  
}
avatar
文章
阅读
粉丝