AsyncTask源码分析

转载请注明出处：http://blog.csdn.net/fishle123/article/details/50188729

在Android开发中，AsyncTask经常用来执行一些耗时任务，并且在任务完成可以更新UI。本文通过对AsyncTask源码的分析来分析其实现机制，先简单介绍了AsyncTask的基本用法，然后结束AsyncTask怎样与主线程交互，最后深入分析AsyncTask的调度机制，对AsyncTask的使用比较熟悉的可以重点看后半部分。如果有一些Android开发经验的人，读完之后应该对使用 AsyncTask 过程中的一些问题豁然开朗，开发经验较少的也可以从中找到使用过程中的注意事项。

1 什么时候使用AsyncTask

在 Android 有一个线程叫做 UI 线程，也叫做 Main Thread或主线程，除了 Main Thread 之外的线程都可称为 Worker Thread。Main Thread 主要负责控制 UI 页面的显示、更新、交互等。因此所有在 UI 线程中的操作要求越短越好，只有这样用户才会觉得操作比较流畅，否则就会出现卡顿，如果阻塞主线程超过5秒，系统就出抛出ANR异常。通常我们会把一些比较耗时的操作，例如网络请求、数据库操作、复杂计算等逻辑都放到到后台线程中运行，这样就可以避免阻塞主线程。很多时候，后台线程运行完成或运行过程中，会需要更新UI，而更新UI必须在主线程中，AsyncTask正是因此而生。下面给出一个简单的示例：模拟一个计算任务，并定时更新计算任务的进度。

 

public class MainActivity extends Activity {
 
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
 
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
 
@Override
protected void onResume() {
// TODO Auto-generated method stub
super.onResume();
Task task = new Task();
task.execute(100);
}
 
public class Task extends AsyncTask<Integer, Integer, Boolean> {
private ProgressDialog mDialog;
@Override
protected void onPreExecute() {
// TODO Auto-generated method stub
super.onPreExecute();
mDialog = new ProgressDialog(MainActivity.this);
mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
//mDialog.setProgress(100);
mDialog.setIndeterminate(false);
mDialog.setProgress(0);
mDialog.setMax(100);
mDialog.show();
}
 
@Override
protected Boolean doInBackground(Integer... params) {
// TODO Auto-generated method stub
int max = params[0];
int n = 0;
int progress = 0;
while (n <= max) {
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
n++;
progress = (100*n) / max;
publishProgress(progress);
}
return n==max;
}
 
@Override
protected void onProgressUpdate(Integer... values) {
// TODO Auto-generated method stub
super.onProgressUpdate(values);
mDialog.setProgress(values[0]);
}
 
@Override
protected void onPostExecute(Boolean result) {
// TODO Auto-generated method stub
super.onPostExecute(result);
mDialog.dismiss();
Toast.makeText(MainActivity.this, "task finshed", Toast.LENGTH_SHORT).show();
 
}
}
}

 

2 AsyncTask怎样与主线程交互

在后台线程中，常用的与主线程交互的方式有Handler，或者调用Activity.runOnUiThread。在AsyncTask中使用的就是Handler。通过AsyncTask.publishProgeress()就可以证实这一点：

 

private static final InternalHandler sHandler = new InternalHandler();
 
...//省略部分代码
 
 protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
}
 
 private static class InternalHandler extends Handler {
        @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;
            }
        }
    }

 

在publishProgress中就是通过handler给主线程发送消息，这个handler必须是在主线程中创建的，所以AsyncTask也必须在主线程创建。

3 AsyncTask任务执行机制

先看一下AsyncTask的构造函数：

 

public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
 
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                return postResult(doInBackground(mParams));
            }
        };
 
        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                    final Result result = get();
 
                    postResultIfNotInvoked(result);
                } 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);
                } catch (Throwable t) {
                    throw new RuntimeException("An error occured while executing "
                            + "doInBackground()", t);
                }
            }
        };
    }
 
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
}
 
private Result postResult(Result result) {
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

 

在第2--9行中，创建了一个Callable对象mWorker,在call方法中调用

 

postResult(doInBackground(mParams))

 

来执行我们在doInBackgound中定义的任务，并在任务完成后通过postResult在主线程中接受结果。因为AsyncTask需要在任务执行完返回结果，所以这里通过Callable来执行任务，而不是Runnable。postResult通过Handler来把结果传递给主线程，如第37--42行所示。在构造函数中还有一个Future对象mFuture ，通过mFuture 我们可以通过调用AsyncTask.get()方法在AsyncTask执行完成后的任何时刻去获取异步任务的结果（Callable的返回结果）,我们还可以通过mFuture 来管理任务，比如取消任务：

 

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

 

当然，如果任务已经开始运行了或者已经完成，调用AsyncTask.cancel()并不会影响任务的执行。但是在任务执行前取消，就会不会开始任务了。如果任务已经开始，调用cancel方法后，在doOnBackground返回后会调用onCancel方法，并且不会调用onPostExecute方法。如果我们希望即使任务已经开始，仍能cancel，那么在都OnBackground中应该定期去调用isCancelled来检查任务是否需要被取消。

 

现在我们知道AsyncTask是通过Callable和Future来执行和管理我们的任务，Callable任务是在那里执行呢？这里需要看一下AsyncTask.execute()方法：

 

 public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
}
 
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;
    }

 

从第2行，24行可以看到，这里通过一个Excutor来执行在构造函数中定义的mFuture,以此来执行我们定义的任务。从第8--15行可以看出，同一个AsyncTask只能执行一次。

在Android Donut(Android 1.6)之前,所有的AsyncTask异步任务都是顺序执行的，从Android 1.6开始改为并发执行，但是从Android Honeycomb (Android 3.1)开始，又改成顺序执行了。不过，我们也可以自己控制AysncTask为并发执行：

 

task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,arg);

 

当然，我们也可以定义自己的Executor.

 

我们在来看一下，AsyncTask中默认的Exector:

 

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);
 
    /**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
 
    private static final InternalHandler sHandler = new InternalHandler();
 
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
   
    
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
 
    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);
            }
        }
}

 

从第27到60行，可以看出AsyncTask默认任务调度Executor使用的是一个自定义的SerialExecutor ，它是会顺序的去调度每一个Task，如果我们在一个AsyncTask中启动了另外一个AsyncTask，就会形成死锁。因为所有的AsyncTask默认使用的是同一个Exector,具体见第31行。需要注意的是，SerialExecutor只是用来顺序调度任务，真正执行任务的是使用THREAD_POOL_EXECUTOR，它是一个ThreadPoolExcutor,但是任务是线性调度的，执行完一个任务才会执行下一个。THREAD_POOL_EXECUTOR是一个并发执行的Executor,见第19行，默认核心线程池的大小是5，最大线程数128，缓存任务队列是10。

到此，已经分析完AsyncTask的所有核心内容。这里在总结一下AsyncTask使用中的一些使用技巧：

1) 由于 AsyncTask中Handler 用于和主线程交互，所以AsyncTask 的必须在主线程中执行task.execute；

2) AsyncTaskResult 的 doInBackground(mParams)方法执行异步任务运行在子线程中，其他方法运行在主线程中，可以更新UI；

3)不要手动调用AsyncTask 的onPreExecute、doInBackground、onProgressUpdate、 onPostExecute 方法，这些都是由Android 系统自动调用的，它们都是在主线程中执行，所以可以操作UI。

4)可以调用publishProgress来在任务执行过程中更新UI；

5)一个任务 AsyncTask 任务只能被执行一次；

6)运行中可以随时调用 cancel(boolean) 方法取消任务，如果成功调用isCancelled() 会返回 true，并且不会执行 onPostExecute() 方法了，取而代之的是调用 onCancelled() 方法。而且从源码看，如果这个任务正在执行，这个时候调用 cancel 是不会真正的把task结束，而是继续执行，只不过改变的是执行之后的回调 onCancelled而不会调用onPostExecute。

7)AsyncTask默认顺序执行，如果在一个AsyncTask中启动了另外一个AsyncTask，就会形成死锁；可以通过调用executeOnExecutor代替调用execute来执行任务，并且传递一个并发的Excutor给executeOnExecutor，从而使我们的AsyncTask能并发执行，在AsyncTask中的AsyncTask.THREAD_POOL_EXECUTOR 为我们提供了一个并发的Excutor。

一个死锁的例子：

package com.example.hello.myapplication;

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.MotionEvent;

import java.util.concurrent.ExecutionException;

public class MainActivity extends AppCompatActivity {

    private static final String TAG ="MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        AsyncTask<Integer,Integer,Void> task =new AsyncTask<Integer, Integer, Void>() {
            @Override
            protected Void doInBackground(Integer... integers) {
                Log.i(TAG,"task:"+integers[0]);
                AsyncTask<Integer, Integer, Void> subTask = new AsyncTask<Integer, Integer, Void>() {
                    @Override
                    protected Void doInBackground(Integer... integers) {
                        Log.i(TAG,"subTask:"+integers[0]);
                        return null;
                    }
                };
                subTask.execute(22);//这里只是把任务放到队列

                try {
                    Log.i(TAG,"task: wait");
                    subTask.get();//这里要等subTask执行完，但是如果task不执行完subTask就不会执行，因此会死锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }

                Log.i(TAG,"task: finish");
                return null;
            }
        };
        task.execute(11);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        return super.dispatchTouchEvent(ev);
    }
}