AsyncTask封裝了Thread和Handler，是一種輕量級的異步任務(wù)類。

參數(shù)

class MyAsyncTask extends AsyncTask<Params, Progress, Result>

Params：執(zhí)行execute時需要傳入的參數(shù)，可以是Void。
Progress：更新進(jìn)度時用到的類型。
Result：任務(wù)執(zhí)行完成后返回的結(jié)果類型。

核心方法

doInBackground：異步執(zhí)行后臺線程需要完成的任務(wù)。
onPreExecute：執(zhí)行后臺耗時操作前被調(diào)用，通常進(jìn)行初始化操作。
onPostExecute：doInBackground執(zhí)行完成后調(diào)用的方法。
onProgressUpdate：doInBackground中調(diào)用publishProgress會執(zhí)行該方法，用于更新進(jìn)度。
onCancelled：異步任務(wù)被取消時執(zhí)行該方法。

doInBackground在線程池中執(zhí)行，其余方法均在主線程中執(zhí)行，可以直接更新UI。

基本用法

Demo運(yùn)行圖.png

class MyAsyncTask extends AsyncTask<String, Integer, String> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            progressBar.setMax(100);
            bt_start.setText("開始下載");
        }

        @Override
        protected String doInBackground(String... strings) {
            for (int i = 0; i < 101; i++) {
                if (isCancelled()) {
                    break;
                }
                publishProgress(i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            if (isCancelled()) {
                return;
            }
            progressBar.setProgress(values[0]);
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            bt_start.setText("下載完成");
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
        }
    }

啟動方式

        myAsyncTask = new MyAsyncTask();
        myAsyncTask.execute("downLoadUrl");

從Android3.0開始，默認(rèn)情況下AsyncTask是串行執(zhí)行的，要想并行執(zhí)行，可以嘗試下面方法

        myAsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"downLoadUrl");

源碼初探

    @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

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

當(dāng)執(zhí)行execute方法時，可以看到調(diào)用了executeOnExecutor，并加入了默認(rèn)的sDefaultExecutor。也可以看到，當(dāng)重復(fù)執(zhí)行時就會拋出異常。

    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

Executor是一個接口，百度翻譯是執(zhí)行者，就是用來執(zhí)行提交的任務(wù)的。
所以不管調(diào)用AsyncTask.execute(Params),
還是調(diào)用AsyncTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR,Params),
效果是一樣的，用的都是默認(rèn)的Executor，即sDefaultExecutor。

 public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

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

ArrayDeque采用循環(huán)數(shù)組實(shí)現(xiàn)，mTasks為要執(zhí)行的任務(wù)隊列，從SerialExecutor可以看出，當(dāng)調(diào)用AsyncTask.execute(Params)或者調(diào)用AsyncTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR,Params),并不是立即執(zhí)行任務(wù)，而是通過mTasks.offer方法向隊尾插入了執(zhí)行任務(wù)，只有當(dāng)scheduleNext方法取到它時，才會通過THREAD_POOL_EXECUTOR執(zhí)行，mTasks.poll為獲取并刪除隊首任務(wù)，所以通過這兩種方法執(zhí)行的都是串行任務(wù)。

等等

THREAD_POOL_EXECUTOR在前邊遇到過，是的，沒錯。就是在要執(zhí)行并行任務(wù)的時候用到的它。

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

ThreadPoolExecutor是一個線程池，用來執(zhí)行提交的任務(wù)，所以當(dāng)參數(shù)設(shè)置為THREAD_POOL_EXECUTOR時，沒有一系列的添加隊列操作，而是在executeOnExecutor方法中直接執(zhí)行，所以這種方法執(zhí)行任務(wù)是并行的。

注意事項

AsyncTask對象必須在主線程創(chuàng)建，execute方法也必須在主線程調(diào)用，且execute只能調(diào)用一次。

取消任務(wù)

        myAsyncTask.cancel(true);

調(diào)用cancel方法取消任務(wù)是否可以有效的取消當(dāng)前任務(wù)？cancel掉當(dāng)前任務(wù)后，此時新建AsyncTask對象并執(zhí)行，發(fā)現(xiàn)會有短暫的停頓后才會執(zhí)行新建的任務(wù)，因為cancel只是改變了任務(wù)的狀態(tài)，并沒有真正的停止任務(wù)，cancel掉的任務(wù)在隊列中執(zhí)行完成后才會執(zhí)行新創(chuàng)建的任務(wù)。所以，要在doInBackground中進(jìn)行isCancelled判斷，如果為true，則直接跳出，避免資源、時間的浪費(fèi)。

最后

有什么解釋不對還望各位大神指正