android AsyncTask 源码解读

android AsyncTask 源码解读

AsyncTask是对Executor和Handler的组合包装类
AsyncTask是Android提供的轻量级的异步类，它使创建异步任务变得更加简单，不再需要编写任务线程和Handler实例即可完成相同的任务

AsyncTask执行过程：
1、AsyncTask启动、执行过程：execute(Params… params) => executeOnExecutor() => execute(Runnable runnable) => sDefaultExecutor.execute(runnable)
2、任务执行阶段：调用顺序doInBackground()=>publishProgress()=>onProgressUpdate()，阶段性结果
3、执行结束过程调用： 1、cancel() => onCancelled()（需在doInBackground()返回后） UI线程调用。 2、调用isCancelled()，检查执行状态

public abstract class AsyncTask<Params, Progress, Result> { //Params: 传递给异步任务执行时的参数的类型//Progress: 执行的进度返回给UI线程的参数的类型//Result: 异步任务执行完后返回给UI线程的结果的类型    private static final String LOG_TAG = "AsyncTask";    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors(); // 获取CPU核数    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;    /*     //android     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); // 实例化原子整型类mCount，则mCount的方法是线程安全的        public Thread newThread(Runnable r) {            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());         }    };    private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128); //链表阻塞队列， 容量大小128    /**     * 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);     public static final Executor SERIAL_EXECUTOR = new SerialExecutor(); // 同步线程池（串行线程池）: 同一时间只能执行一个任务，串行执行任务，同步方法内调用THREAD_POOL_EXECUTOR.execute()达到最终串行执行任务    private static final int MESSAGE_POST_RESULT = 0x1;    private static final int MESSAGE_POST_PROGRESS = 0x2;    private static final InternalHandler sHandler = new InternalHandler(); // 静态内部类InternalHandler，其绑定了主线程的Looper和消息队列，完成消息的产生、发送、处理，    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR; // 默认线程池为串行线程池    private final WorkerRunnable<Params, Result> mWorker;    private final FutureTask<Result> mFuture;    private volatile Status mStatus = Status.PENDING;    private final AtomicBoolean mTaskInvoked = new AtomicBoolean(); //标识当前任务是否调用执行，原子布尔型变量（原子操作就是不能被线程调度机制中断的操作）    private static class SerialExecutor implements Executor {        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>(); // 数组双端队列，没有容量限制，其容量可自增长， mTasks的集合来保证任务的顺序执行        Runnable mActive;        public synchronized void execute(final Runnable r) { // 同步方法中维护双端队列，同时操作双端队列、调用并发线程池进行任务提交、执行            mTasks.offer(new Runnable() { //通过队列的offer方法将封装了final Runnable r的new Runnable对象添加到队尾                public void run() {                    try {                        r.run();  //执行r的run方法（最后在在线程池中执行），实现任务功能                    } finally {                        scheduleNext(); // 同步方法中调用并发线程池提交任务                    }                }            });            if (mActive == null) { //当前没有可执行任务，调用scheduleNext方法执行一个Runnable任务                scheduleNext();            }        }        protected synchronized void scheduleNext() {            if ((mActive = mTasks.poll()) != null) { //通过mTasks的poll方法出队操作，删除并返回队头的Runnable，并将返回的Runnable赋值给mActive，                THREAD_POOL_EXECUTOR.execute(mActive); // 调用THREAD_POOL_EXECUTOR的execute方法，提交mActive任务，并在线程池中执行mActive.run()方法            }        }    }    public enum Status {        //Indicates that the task has not been executed yet.        PENDING,        // Indicates that the task is running.        RUNNING,        //Indicates that {@link AsyncTask#onPostExecute} has finished.        FINISHED,    }    //异步任务的当前状态以及状态转变：PENDING=>RUNNING=>FINISHED    public static void init() {        sHandler.getLooper();    }    public static void setDefaultExecutor(Executor exec) {        sDefaultExecutor = exec;    }    /**     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.     */    public AsyncTask() {        mWorker = new WorkerRunnable<Params, Result>() { //实现了Callable接口的call方法            public Result call() throws Exception { //call方法是在线程池的线程中执行的，而不是在主线程中运行                mTaskInvoked.set(true); //将mTaskInvoked设置为true，表示任务开始执行                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); // 将当前执行call方法的线程设置为后台线程                Result result = doInBackground(mParams); //在线程池的工作线程中执行doInBackground方法，执行实际的任务，并返回结果                Binder.flushPendingCommands();                return postResult(result);  //将执行完的结果传递给postResult方法            }        };        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 void postResultIfNotInvoked(Result result) {        final boolean wasTaskInvoked = mTaskInvoked.get();        if (!wasTaskInvoked) {            postResult(result);        }    }    private Result postResult(Result result) {        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result)); // 发送“结果消息”        message.sendToTarget();        return result;    }    public final Status getStatus() {        return mStatus;    }    /**     * Override this method to perform a computation on a background thread. The     * specified parameters are the parameters passed to {@link #execute}     * by the caller of this task.     *     * This method can call {@link #publishProgress} to publish updates on the UI thread.     *     * @param params The parameters of the task.     *     * @return A result, defined by the subclass of this task.     */    protected abstract Result doInBackground(Params... params);    /**     * Runs on the UI thread before doInBackground()     */    protected void onPreExecute() {    }    /**     * Runs on the UI thread after doInBackground(). This method won't be invoked if the task was cancelled     * @param result： The result of the operation computed by #doInBackground     */    @SuppressWarnings({"UnusedDeclaration"})    protected void onPostExecute(Result result) {    }    /**     * Runs on the UI thread after publishProgress() is invoked.     * @param values The values indicating progress.     */    @SuppressWarnings({"UnusedDeclaration"})    protected void onProgressUpdate(Progress... values) {    }    @SuppressWarnings({"UnusedParameters"})    protected void onCancelled(Result result) {        onCancelled();    }        protected void onCancelled() {    }    /**     * Returns <tt>true</tt> if this task was cancelled before it completed     * normally. If you are calling {@link #cancel(boolean)} on the task,     * the value returned by this method should be checked periodically from     * {@link #doInBackground(Object[])} to end the task as soon as possible.     *     * @return <tt>true</tt> if task was cancelled before it completed     */    public final boolean isCancelled() {        return mFuture.isCancelled();    }    /**     * <p>Attempts to cancel execution of this task.  This attempt will     * fail if the task has already completed, already been cancelled,     * or could not be cancelled for some other reason. If successful,     * and this task has not started when <tt>cancel</tt> is called,     * this task should never run. If the task has already started,     * then the <tt>mayInterruptIfRunning</tt> parameter determines     * whether the thread executing this task should be interrupted in     * an attempt to stop the task.</p>     *     * @param mayInterruptIfRunning       * true：if the thread executing this task should be interrupted; otherwise, in-progress tasks are allowed to complete.     * @return false： if the task could not be cancelled, typically because it has already completed normally; true：otherwise     *     * @see #isCancelled()     * @see #onCancelled(Object)     */    // 取消当前执行任务    public final boolean cancel(boolean mayInterruptIfRunning) {  //3、执行结束过程调用： cancel() => doInBackground()返回 => onCancelled() UI线程调用。 2、调用isCancelled()，检查执行状态        return mFuture.cancel(mayInterruptIfRunning);     }    public final Result get() throws InterruptedException, ExecutionException {        return mFuture.get();    }    /**     * Waits if necessary for at most the given time for the computation to complete, and then retrieves its result.     * @param timeout Time to wait before cancelling the operation.     * @param unit The time unit for the timeout.     * @return The computed result.     */    //等待计算完成，获取任务状态结果    public final Result get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {        return mFuture.get(timeout, unit);    }    /**     * Executes the task with the specified parameters. The task returns     * itself (this) so that the caller can keep a reference to it.     * This method must be invoked on the UI thread.     * @param params The parameters of the task.     * @return This instance of AsyncTask.     */    //传入参数，开始执行任务    public final AsyncTask<Params, Progress, Result> execute(Params... params) { // 1、AsyncTask启动、执行过程：execute(Params... params) => executeOnExecutor() => execute(Runnable runnable) => sDefaultExecutor.execute(runnable)        return executeOnExecutor(sDefaultExecutor, params);    }    /**     * Executes the task with the specified parameters. The task returns     * itself (this) so that the caller can keep a reference to it.     * This method must be invoked on the UI thread.     *     * @param exec The executor to use. #THREAD_POOL_EXECUTOR} is available as a convenient process-wide thread pool for tasks that are loosely coupled.     * @param params The parameters of the task.     *     * @return This instance of AsyncTask.     */    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;    }    public static void execute(Runnable runnable) {        sDefaultExecutor.execute(runnable); //由默认线程池提交、执行任务    }    protected final void publishProgress(Progress... values) { // 2、任务执行阶段：调用顺序doInBackground()=>publishProgress()=>onProgressUpdate()，阶段性结果        if (!isCancelled()) {            sHandler.obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult<Progress>(this, values)).sendToTarget();        }    }    private void finish(Result result) {        if (isCancelled()) {            onCancelled(result); // 任务被取消，执行onCancelled()方法        } else {            onPostExecute(result); //结果发传递给onPostExecute()方法, 可在UI线程中刷新结果        }        mStatus = Status.FINISHED; //AsyncTask的状态设置为完成状态    }    private static class InternalHandler extends Handler {        public InternalHandler() {                super(Looper.getMainLooper()); //Looper类的getMainLooper静态方法，该方法返回主线程的Looper，表示InternalHandler绑定了主线程        }        @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); // 可在UI线程中刷新显示执行进度                    break;            }        }    }    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {        Params[] mParams;    }    @SuppressWarnings({"RawUseOfParameterizedType"})    private static class AsyncTaskResult<Data> { // 封装AsyncTask与相关数据成AsyncTaskResult        final AsyncTask mTask;        final Data[] mData; //存储的数据        AsyncTaskResult(AsyncTask task, Data... data) { //data是可变数组            mTask = task;            mData = data;        }    }}

AsyncTask使用关键函数：
protected void onPreExecute(); // 当任务执行之前开始调用此方法，可以在这里显示进度对话框，属UI主线程。
protected abstract Result doInBackground(Params… params);//耗时操作，例如网络请求任务。由AsyncTask线程池中的线程调用执行异步任务
protected void onPostExecute(Result result)；//处理doInBackground得到的数据，能够对UI进行操作，属UI主线程
protected void onProgressUpdate(Progress… values); //可以使用进度条增加用户体验度。 属UI主线程，用于显示任务执行的进度。
protected void onCancelled(Result result); //用户调用取消时，会调用此方法，属UI主线程

使用AsyncTask类，须遵守的准则：
Task的实例必须在UI thread中创建；
execute方法必须在UI thread中调用；
不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params…), onProgressUpdate(Progress…)这几个方法；
该task只能被执行一次，多次调用时将会出现异常；

示例：

public class MainActivity extends Activity{    private Button button;    private Button cancel;    private ImageView imageView;    private ProgressDialog progressDialog;    private final String IMAGE_PATH = "http://developer.android.com/images/home/kk-hero.jpg";    DownloadAsyncTask task;    @Override    protected void onCreate(Bundle savedInstanceState)    {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        imageView = (ImageView)findViewById(R.id.imageView);        progressDialog = new ProgressDialog(MainActivity.this);        progressDialog.setTitle("Image Downloading");        progressDialog.setMessage("........Downloading......");        progressDialog.setCancelable(false);        progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);           button = (Button)findViewById(R.id.button);           button.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v){                task = new DownloadAsyncTask();                task.execute(IMAGE_PATH); //AsyncTask任务只能被执行一次，传入参数，开始执行异步任务                                                             //函数原型：public final AsyncTask<Params, Progress, Result> execute(Params... params)                cancel.setEnabled(true);            }        });        cancel = (Button) findViewById(R.id.cancel);          cancel.setOnClickListener(new View.OnClickListener() {              @Override              public void onClick(View v) {                           task.cancel(true);   //取消一个正在执行的任务            }          });        cancel.setEnabled(false);     }    public class DownloadAsyncTask extends AsyncTask<String, Integer, byte[]> //Params: String类型，指定的URL路径，进度参数Progress: Integer类型，返回值类型Result：byte[]类型    {        @Override        protected void onPreExecute(){ // UI 线程执行            super.onPreExecute();            progressDialog.show(); //ProgressDialog显示出来        }        @Override        protected byte[] doInBackground(String... params) // 异步线程（后台线程）中执行        {              ByteArrayOutputStream bos=new ByteArrayOutputStream();            byte[] imgBytes = new byte[]{};            try {               URL url=new URL(params[0]);               HttpURLConnection con=(HttpURLConnection)url.openConnection();               con.setConnectTimeout(5000);                 con.setReadTimeout(5000);                con.setDoInput(true);               con.connect();               InputStream is=con.getInputStream();               long maxSize=con.getContentLength(); //获取文件的大小               byte[] buffer=new byte[1024];               int len=-1;               long total_length=0;               while((len=is.read(buffer))!=-1){                   bos.write(buffer,0,len);                   bos.flush();                   total_length += len;                   int progress = ((int)(total_length/(float)maxSize) * 100);  // 得到当前图片下载的进度                   publishProgress(progress); //将当前进度更新给onProgressUpdate方法               }                         is.close(); //关闭输入流               con.disconnect(); //关闭连接               byte[] imgBytes=bos.toByteArray();           } catch (MalformedURLException e) {              e.printStackTrace();           } catch (IOException e) {              e.printStackTrace();           } catch (InterruptedException e) {              e.printStackTrace();           }           return imgBytes;        }        @Override        protected void onProgressUpdate(Integer... values){ // UI 线程执行            super.onProgressUpdate(values);              progressDialog.setProgress(values[0]); //更新ProgressDialog的进度条        }        @Override        protected void onPostExecute(byte[] result){ // UI 线程执行            super.onPostExecute(result);            Bitmap bitmap = BitmapFactory.decodeByteArray(result, 0, result.length);            imageView.setImageBitmap(bitmap);            progressDialog.dismiss();        }        @Override          protected void onCancelled() {   //取消执行中的任务时更改UI             progressDialog.setProgress(0);              cancel.setEnabled(false);          }     }}