Android異步處理四：AsyncTask的實現原理

本博文地址：http://blog.csdn.net/mylzc/article/details/6774131，轉載請註明出處

Android異步處理系列文章索引

Android異步處理一：使用Thread+Handler實現非UI線程更新UI界面

Android異步處理二：使用AsyncTask異步更新UI界面

Android異步處理三：Handler+Looper+MessageQueue深入詳解

Android異步處理四：AsyncTask的實現原理

在《Android異步處理二：使用AsyncTask異步更新UI界面》一文中，我們介紹瞭如何使用AsyncTask實現異步下載圖片，並且更新圖片到UI界面的方法。本篇我們將學習Framework層AsyncTask的實現原理。

概述：AsyncTask的本質是一個線程池，所有提交的異步任務都會在這個線程池中的工作線程內執行，當工作線程需要跟UI線程交互時，工作線程會通過向在UI線程創建的Handler（原理見：《Android異步處理三：Handler+Looper+MessageQueue深入詳解》）傳遞消息的方式，調用相關的回調函數，從而實現UI界面的更新。

例子：

本章還是以《Android異步處理二：使用AsyncTask異步更新UI界面》中的例子說明AsyncTask的實現原理。

這個例子是在後臺下載CSDN的LOGO，下載完成後在UI界面上顯示出來。

AsyncTask.java

[java] view plaincopy

package com.zhuozhuo;


import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.Toast;

public class AsyncTaskActivity extends Activity {

    private ImageView mImageView;
    private Button mButton;
    private ProgressBar mProgressBar;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mImageView= (ImageView) findViewById(R.id.p_w_picpathView);
        mButton = (Button) findViewById(R.id.button);
        mProgressBar = (ProgressBar) findViewById(R.id.progressBar);
        mButton.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                GetCSDNLogoTask task = new GetCSDNLogoTask();
                task.execute("http://csdnimg.cn/www/p_w_picpaths/csdnindex_logo.gif");
            }
        });
    }

    class GetCSDNLogoTask extends AsyncTask<String,Integer,Bitmap> {//繼承AsyncTask

        @Override
        protected Bitmap doInBackground(String... params) {//處理後臺執行的任務，在後臺線程執行
            publishProgress(0);//將會調用onProgressUpdate(Integer... progress)方法
            HttpClient hc = new DefaultHttpClient();
            publishProgress(30);
            HttpGet hg = new HttpGet(params[0]);//獲取csdn的logo
            final Bitmap bm;
            try {
                HttpResponse hr = hc.execute(hg);
                bm = BitmapFactory.decodeStream(hr.getEntity().getContent());
            } catch (Exception e) {

                return null;
            }
            publishProgress(100);
            //mImageView.setImageBitmap(result); 不能在後臺線程操作ui
            return bm;
        }

        protected void onProgressUpdate(Integer... progress) {//在調用publishProgress之後被調用，在ui線程執行
            mProgressBar.setProgress(progress[0]);//更新進度條的進度
         }

         protected void onPostExecute(Bitmap result) {//後臺任務執行完之後被調用，在ui線程執行
             if(result != null) {
                 Toast.makeText(AsyncTaskActivity.this, "成功獲取圖片", Toast.LENGTH_LONG).show();
                 mImageView.setImageBitmap(result);
             }else {
                 Toast.makeText(AsyncTaskActivity.this, "獲取圖片失敗", Toast.LENGTH_LONG).show();
             }
         }

         protected void onPreExecute () {//在 doInBackground(Params...)之前被調用，在ui線程執行
             mImageView.setImageBitmap(null);
             mProgressBar.setProgress(0);//進度條復位
         }

         protected void onCancelled () {//在ui線程執行
             mProgressBar.setProgress(0);//進度條復位
         }

    }


}

main.xml

[html] view plaincopy

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <ProgressBar android:layout_width="fill_parent" android:layout_height="wrap_content" android:id="@+id/progressBar" style="?android:attr/progressBarStyleHorizontal"></ProgressBar>
    <Button android:id="@+id/button" android:text="下載圖片" android:layout_width="wrap_content" android:layout_height="wrap_content"></Button>
    <ImageView android:id="@+id/p_w_picpathView" android:layout_height="wrap_content"
        android:layout_width="wrap_content" />
</LinearLayout>

mainifest.xml

[html] view plaincopy

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.zhuozhuo"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="10" />
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".AsyncTaskActivity"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

運行結果：

 

分析：

在分析實現流程之前，我們先了解一下AsyncTask有哪些成員變量。

[java] view plaincopy

private static final int CORE_POOL_SIZE =5;//5個核心工作線程
private static final int MAXIMUM_POOL_SIZE = 128;//最多128個工作線程
private static final int KEEP_ALIVE = 1;//空閒線程的超時時間爲1秒

private static final BlockingQueue<Runnable> sWorkQueue =
        new LinkedBlockingQueue<Runnable>(10);//等待隊列

private static final ThreadPoolExecutorsExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
        MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue,sThreadFactory);//線程池是靜態變量，所有的異步任務都會放到這個線程池的工作線程內執行。

 

回到例子中，點擊按鈕之後會新建一個GetCSDNLogoTask對象：

[java] view plaincopy

GetCSDNLogoTask task = new GetCSDNLogoTask();

此時會調用父類AsyncTask的構造函數：

AsyncTask.java

[java] view plaincopy

public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                return doInBackground(mParams);
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                Message message;
                Result result = null;

                try {
                    result = 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) {
                    message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,
                            new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));
                    message.sendToTarget();//取消任務，發送MESSAGE_POST_CANCEL消息
                    return;
                } catch (Throwable t) {
                    throw new RuntimeException("An error occured while executing "
                            + "doInBackground()", t);
                }

                message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                        new AsyncTaskResult<Result>(AsyncTask.this, result));//完成任務，發送MESSAGE_POST_RESULT消息並傳遞result對象
                message.sendToTarget();
            }
        };
    }

WorkerRunnable類實現了callable接口的call()方法，該函數會調用我們在AsyncTask子類中實現的doInBackground(mParams)方法，由此可見，WorkerRunnable封裝了我們要執行的異步任務。FutureTask中的protected void done() {}方法實現了異步任務狀態改變後的操作。當異步任務被取消，會向UI線程傳遞MESSAGE_POST_CANCEL消息，當任務成功執行，會向UI線程傳遞MESSAGE_POST_RESULT消息，並把執行結果傳遞到UI線程。

由此可知，AsyncTask在構造的時候已經定義好要異步執行的方法doInBackground(mParams)和任務狀態變化後的操作（包括失敗和成功）。

當創建完GetCSDNLogoTask對象後，執行

[java] view plaincopy

task.execute("http://csdnimg.cn/www/p_w_picpaths/csdnindex_logo.gif");

此時會調用AsyncTask的execute(Params...params)方法

AsyncTask.java

[java] view plaincopy

public final AsyncTask<Params,Progress, Result> execute(Params... params) {
        if (mStatus != Status.PENDING) {
            switch (mStatus) {
                case RUNNING:
                    throw newIllegalStateException("Cannot execute task:"
                            + " the taskis already running.");
                case FINISHED:
                    throw newIllegalStateException("Cannot execute task:"
                            + " the taskhas already been executed "
                            + "(a task canbe executed only once)");
            }
        }

        mStatus = Status.RUNNING;

        onPreExecute();//運行在ui線程，在提交任務到線程池之前執行

        mWorker.mParams = params;
        sExecutor.execute(mFuture);//提交任務到線程池

        return this;
}

當任務正在執行或者已經完成，會拋出IllegalStateException，由此可知我們不能夠重複調用execute(Params...params)方法。在提交任務到線程池之前，調用了onPreExecute()方法。然後才執行sExecutor.execute(mFuture)是任務提交到線程池。

前面我們說到，當任務的狀態發生改變時（1、執行成功2、取消執行3、進度更新），工作線程會向UI線程的Handler傳遞消息。在《Android異步處理三：Handler+Looper+MessageQueue深入詳解》一文中我們提到，Handler要處理其他線程傳遞過來的消息。在AsyncTask中，InternalHandler是在UI線程上創建的，它接收來自工作線程的消息，實現代碼如下：

AsyncTask.java

[java] view plaincopy

private static class InternalHandler extends Handler {
       @SuppressWarnings({"unchecked","RawUseOfParameterizedType"})
        @Override
        public voidhandleMessage(Message msg) {
            AsyncTaskResult result =(AsyncTaskResult) msg.obj;
            switch (msg.what) {
                caseMESSAGE_POST_RESULT:
                    // There is onlyone result
                    result.mTask.finish(result.mData[0]);//執行任務成功
                    break;
                caseMESSAGE_POST_PROGRESS:
                   result.mTask.onProgressUpdate(result.mData);//進度更新
                    break;
                caseMESSAGE_POST_CANCEL:
                    result.mTask.onCancelled();//取消任務
                    break;
            }
        }
    }

當接收到消息之後，AsyncTask會調用自身相應的回調方法。

總結：

1、 AsyncTask的本質是一個靜態的線程池，AsyncTask派生出的子類可以實現不同的異步任務，這些任務都是提交到靜態的線程池中執行。

2、線程池中的工作線程執行doInBackground(mParams)方法執行異步任務

3、當任務狀態改變之後，工作線程會向UI線程發送消息，AsyncTask內部的InternalHandler響應這些消息，並調用相關的回調函數