Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> 關於Android編程 >> 關於AsyncTask的一點愚見

關於AsyncTask的一點愚見

編輯:關於Android編程

在Android開發中,為了避免出現ANR現象,主要是指來自於接觸事件響應事件過長來說,我們開發者通常會將耗時長的操作,如網絡操作,大圖片加載,IO操作等等會放在子線程中去處理。

而Android中線程除了來自於Java的Thread,Executor生成器之外,還有已經封裝好的AsyncTask,IntentService,HandlerThread。

而本文就開始從AsyncTask開始說起自己的感悟吧。

AsyncTask 是一種輕量級別的異步任務類,它在線程池中執行後台人物,然後把執行進度以及結果傳到主線程中。在AsyncTask中復用了Handler和Thread。

值得注意有三點:
1.AsyncTask作為輕量級的異步操作不適宜做耗時太過長的操作,畢竟AsyncTask核心線程只有5個,緩沖隊列是10。倘若隊列

public abstract class AsyncTask {
    private static final String LOG_TAG = "AsyncTask";

    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 BlockingQueue sWorkQueue =
            new LinkedBlockingQueue(10);

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread More ...newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
            MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    private static final int MESSAGE_POST_CANCEL = 0x3;

從上面的代碼可以清晰的知道AsyncTask抽象類裡面調用了同步隊列長度為10的LinkBlockingQueue來對任務進行緩沖,同時聲明了一個核心線程數為5,線程池最大容量為128的線程池。(而在android5.0中同步隊列為128)

換句話說,一旦做出超出這個線程池最大容納量,就會造成後續的線程進入到阻塞狀態。

2.AsyncTask要在主線程中聲明。
且看ActivityThread中main函數,這就是我們想要知道的android對應在Java中的入口函數。

    public static void main(String[] args) {
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());

        Security.addProvider(new AndroidKeyStoreProvider());

        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("");

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        AsyncTask.init();

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

從上面的入口函數可以知道,AsyncTask初始化在主線程,同時在主線程Looper了一個MainLooper,而其中AsyncTask復用了Handler,這個Handler也是來源於MainLooper。這也從側面印證了AsyncTask必須聲明在主線程.

3.不要在主線程中直接調用onPreExecute(),onPostExecute,doInBackground,on-ProgressUpdate方法。

這裡就就繼續介紹AsyncTask使用方法。首先可以從第一段代碼看到AsyncTask是一個抽象類,那麼我們必須繼承這個抽象類並且實現其中抽象方法,分別是:
1.onPreExecute
2.doInBackground
3.onProgressUpdate
4.onPostExecute
這四個方法。

這四個方法分別的作用分別是:
1.onPreExecute():執行在主線程中,在異步任務開始前,要做的准備工作。

2.doInBackground(Params…params):這個方法執行在線程池中,用於執行異步任務,Params表示異步任務參數。在這個方法中可以調用publishProgress(Progress…value)來更新任務進度,同時publishProgress將會調用onProgressUpdate。

3.onProgressUpdate(Progress…values)執行在主線程中,當後台任務執行進度發生改變時,該方法會調用。

4.onPostExecute(Result result)執行在主線程中,在異步任務執行之後,這個方法才會調用,result就是doInBackground的返回值。

下面是一個AsyncTask的簡單控制長條型進度條的Demo:

public class MainActivity extends Activity {
    private ProgressBar bar;
    private Button button;
    private TextView text;
    private Button cancel;
    private DownLoadTask dtask; 
    private Button sIntent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bar = (ProgressBar)findViewById(R.id.progress);
        button = (Button)findViewById(R.id.start);
        text = (TextView)findViewById(R.id.text);
        cancel = (Button)findViewById(R.id.cancel);
        sIntent = (Button)findViewById(R.id.intentService);
        cancel.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                if(dtask instanceof DownLoadTask){
                    dtask.cancel(true);
                }
            }
        });

        button.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                dtask = new DownLoadTask(text, bar);
                dtask.execute(1000);
            }
        });

        sIntent.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                Intent service = new Intent(MainActivity.this, MyIntentService.class);
                Log.e("service", "start");
                service.putExtra("task_action", "Task1");
                startService(service);
                service.putExtra("task_action", "Task2");
                startService(service);
                service.putExtra("task_action", "Task3");
                startService(service);
            }
        });
    }



    class network{
        public void operate(){
            try{
                Thread.sleep(100);
            }catch (InterruptedException e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }
    }

    class DownLoadTask extends AsyncTask{
        private TextView text;
        private ProgressBar bar;

        public DownLoadTask(TextView text,ProgressBar bar){
            super();
            this.text = text;
            this.bar = bar;
        }

        @Override
        protected void onPreExecute(){
            bar.setProgress(0);
            text.setText("Async start");
        }

        @Override
        protected Integer doInBackground(Integer... params) {
            // TODO Auto-generated method stub
            network net = new network();
            int value = 0;
            for(int i = 0;i < 100;i++){
                net.operate();
                value = i;
                publishProgress(i);
            }

            return value;
        }

        @Override
        protected void onPostExecute(Integer result){
            text.setText("AsyncTask End");
        }

        @Override
        protected void onProgressUpdate(Integer... values){
            int value = values[0];
            Log.e("value", ""+value);
            bar.setProgress(value);
            text.setText(String.valueOf(value));
        }

    }

}

在上面Demo中用一個net的class來模擬反應時間較長的任務,同時每隔一定的時間就刷新UI控件。
那麼就是這麼做的:耗時的任務用處理異步任務的doInBackground來完成,而刷新UI控件的方法放在onProgressUpdate進行。這樣就沒有違背UI控件必須在主線程才能才能訪問的原則。

下面繼續來稍微的看看AsyncTask的工作流程,從上面的例子看來AsyncTask是通過execute啟動的。先跳過構造器讓我們看看吧,android5.0下面怎麼做的:

    public final AsyncTask execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

從上面可以知道,execute調用了 executeOnExecutor,那麼繼續跟蹤:

 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;
    }

從上面的代碼,我們可以知道對異常的判斷之後,再獲取AsyncTask狀態以及先處理onPreExecute()這個函數,這也印證了為什麼先處理onPreExecute()這個函數了。獲取完傳入參數之後,在進行異步處理。

在這裡還要提一提AsyncTask這個異步任務和我們熟知的線程池不太一樣,默認的情況下是串行,為什麼這麼說呢?看之前的代碼:

    public final AsyncTask execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

直接execute()的話,會調用默認的線程池sDefaultExecutor,而sDefaultExecutor又是什麼呢?

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

private static class SerialExecutor implements Executor {
        final ArrayDeque mTasks = new ArrayDeque();
        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);
            }
        }
    }

這就應該清楚了吧,sDefaultExecutor是一個來自於SerialExecutor的類,傳入mFuture參數,這是一個在構造器完成了聲明的並發類。接著mFuture將會插入隊列中,如果沒有可運行的任務就會調用THREAD_POOL_EXECUTOR.execute(mActive);來執行下一個任務,因此是默認的。那麼又如何使其變成並發工作,而不是串行工作呢?

從上面的源碼可以看出,真正在處理線程是THREAD_POOL_EXECUTOR這個線程池,如下聲明:

public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

而默認的串行執行,只是因為任務在隊列中阻塞等待。那麼我們不使用sDefaultExecutor來執行AsyncTask,轉而使用THREAD_POOL_EXECUTOR來執行即可。

如下:

new MyAsyncTask("Task1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);

即可完成並發執行。

之前我們跳過了構造器,那麼我們現在來看看裡面的構造器是怎麼實現的:

    public AsyncTask() {
        mWorker = new WorkerRunnable() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                return postResult(doInBackground(mParams));
            }
        };

        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 occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

從上面的代碼,我們可以清晰的看見mWorker的聲明中,實現了抽象類WorkerRunnable,將mTaskInvoked設置為真,代表任務已被調用。而調用了doInBackground的方法最後會在FutureTask這個並發中執行,並且返回值給postResult()。

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

從上面的代碼可以清晰可見這裡面復用了Handler,將返回值通過handler傳回主線程(Hnandler是怎麼回事上一章已經總結了),記下來看看處理器怎麼處理的:

    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;
            }
        }
    }

可以知道,handler在處理兩個內容一個是處理發送過來的信息:

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

檢查是否被調用終止,是怎停止任務,並且下次從頭開始,不是則處理onPostExecute(),來處理返回值。

另一個則是處理publishProgress方法,且看看他是怎麼發送的:

    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult

這樣子就能完全明白了吧,通過publishProgress發送消息到handler之後,轉到onProgressUpdate(Progress…value)方法處理刷新進度操作。

到這裡,AsyncTask的流程就完全結束了。

在這裡要感謝任玉剛的android開發藝術探索。輔助了我去閱讀下面的源碼。

  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved