本文內(nèi)容基于《Android開發(fā)藝術(shù)探索》数苫，強(qiáng)烈推薦，值得一看蒲稳。
參考: http://blog.csdn.net/honeybaby201314/article/details/42680607

AsyncTask是一個(gè)抽象類嗓节，它是由Android封裝的一個(gè)輕量級(jí)異步類（輕量體現(xiàn)在使用方便、代碼簡(jiǎn)潔）撬陵，它的內(nèi)部封裝了兩個(gè)線程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一個(gè)Handler(InternalHandler)珊皿，其中SerialExecutor線程池用于任務(wù)的排隊(duì)，THREAD_POOL_EXECUTOR線程池才真正地執(zhí)行任務(wù)巨税，InternalHandler用于從工作線程切換到主線程蟋定。

1.與Handler+Thread比較

1). AsyncTask

• 優(yōu)點(diǎn)：
  1.使用簡(jiǎn)單，代碼簡(jiǎn)潔草添；
  2.過程可控驶兜，可調(diào)用cancel()取消任務(wù)。
• 缺點(diǎn):
  1.執(zhí)行多個(gè)異步操作并需要更新UI時(shí)就變得復(fù)雜起來(lái)远寸。

2). Handler+Thread

• 優(yōu)點(diǎn):
  1.代碼結(jié)構(gòu)清晰抄淑，功能定義明確；
  2.執(zhí)行多個(gè)異步操作時(shí)驰后，結(jié)構(gòu)清晰肆资，功能明確。
• 缺點(diǎn):
  1.執(zhí)行單一異步處理時(shí)灶芝，實(shí)現(xiàn)起來(lái)相對(duì)來(lái)說(shuō)代碼過多郑原，結(jié)構(gòu)復(fù)雜。

2.使用方法

public abstract class AsyncTask<Params, Progress, Result>

1). 三個(gè)泛型參數(shù):

• Params: 傳入?yún)?shù)類型夜涕，即doInBackground()方法中的參數(shù)類型;
• Progress: 異步任務(wù)執(zhí)行過程中返回的下載進(jìn)度類型犯犁，即publishProgress()和onProgressUpdate()方法中傳入的參數(shù)類型；
• Result: 異步任務(wù)執(zhí)行完返回的結(jié)果類型女器，即doInBackground()方法中返回值的類型酸役。

2). 四個(gè)回調(diào)方法:

• onPreExecute(): 在主線程中執(zhí)行，異步任務(wù)執(zhí)行前驾胆，此方法會(huì)調(diào)用涣澡，可做一些準(zhǔn)備工作；

• doInBackground(): 在線程池中執(zhí)行俏拱，核心方法暑塑，用于執(zhí)行異步操作，此方法中可調(diào)用publishProgress()方法來(lái)更新進(jìn)度锅必，publishProgress()方法會(huì)調(diào)用onProgressUpdate()方法事格，此方法的返回結(jié)果會(huì)傳給onPostExecute()方法；

• onProgressUpdate(): 在主線程中執(zhí)行搞隐，publishProgress()方法會(huì)調(diào)用此方法驹愚，用于更新進(jìn)度；

• onPostExecute(): 在主線程中執(zhí)行劣纲，在異步任務(wù)執(zhí)行結(jié)束后逢捺，此方法會(huì)調(diào)用，一般用于處理返回結(jié)果癞季。

  上面幾個(gè)方法的調(diào)用順序：onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()劫瞳，如果不需要執(zhí)行更新進(jìn)度則為onPreExecute() --> doInBackground() --> onPostExecute(),除了上面四個(gè)方法倘潜，AsyncTask還提供了onCancelled()方法，它同樣在主線程中執(zhí)行志于，當(dāng)異步任務(wù)取消時(shí)涮因，onCancelled()會(huì)被調(diào)用，這個(gè)時(shí)候onPostExecute()則不會(huì)被調(diào)用伺绽，但是要注意的是养泡，AsyncTask中的cancel()方法并不是真正去取消任務(wù)，只是設(shè)置這個(gè)任務(wù)為取消狀態(tài)奈应，我們需要在doInBackground()判斷終止任務(wù)澜掩。

注意：

• 1). AsyncTask必須在主線程中創(chuàng)建實(shí)例，execute()方法也必須在主線程中調(diào)用杖挣；
• 2). 每個(gè)AsyncTask實(shí)例只能執(zhí)行一次execute()肩榕，多次執(zhí)行會(huì)報(bào)錯(cuò)，如需執(zhí)行多次程梦，則需創(chuàng)建多個(gè)實(shí)例点把。
• 3). AsyncTask是采用一個(gè)線程來(lái)串行執(zhí)行任務(wù)橘荠，如需并行執(zhí)行任務(wù)屿附，需調(diào)用executeOnExecutor()方法來(lái)執(zhí)行任務(wù)

3.工作原理

本部分我將從asyncTask.execute(params)、asyncTask.executeOnExecutor(exec, params)哥童、AsyncTask.execute(runnable)三種執(zhí)行方式入手來(lái)分析源碼部分挺份，不考慮通過setDefaultExecutor設(shè)置自定義線程池是的情況(可參考asyncTask.executeOnExecutor(exec, params)方式)，最下面貼有源碼分析

1).asyncTask.execute(params)：

2).asyncTask.executeOnExecutor(exec, params)：

3).AsyncTask.execute(runnable)：

源碼分析來(lái)自http://blog.csdn.net/honeybaby201314/article/details/42680607

public abstract class AsyncTask {  
    private static final String LOG_TAG = AsyncTask;  
  
    //獲取當(dāng)前的cpu核心數(shù)  
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();  
    //線程池核心容量  
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;  
    //線程池最大容量  
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;  
    //過剩的空閑線程的存活時(shí)間  
    private static final int KEEP_ALIVE = 1;  
    //ThreadFactory 線程工廠贮懈，通過工廠方法newThread來(lái)獲取新線程  
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
        //原子整數(shù)匀泊，可以在超高并發(fā)下正常工作  
        private final AtomicInteger mCount = new AtomicInteger(1);  
  
        public Thread newThread(Runnable r) {  
            return new Thread(r, AsyncTask # + mCount.getAndIncrement());  
        }  
    };  
    //靜態(tài)阻塞式隊(duì)列，用來(lái)存放待執(zhí)行的任務(wù)朵你，初始容量：128個(gè)  
    private static final BlockingQueue sPoolWorkQueue =  
            new LinkedBlockingQueue(128);  
  
    /** 
     * 靜態(tài)并發(fā)線程池各聘，可以用來(lái)并行執(zhí)行任務(wù)，盡管從3.0開始抡医，AsyncTask默認(rèn)是串行執(zhí)行任務(wù) 
     * 但是我們?nèi)匀荒軜?gòu)造出并行的AsyncTask 
     */  
    public static final Executor THREAD_POOL_EXECUTOR  
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,  
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);  
  
    /** 
     * 靜態(tài)串行任務(wù)執(zhí)行器躲因，其內(nèi)部實(shí)現(xiàn)了串行控制， 
     * 循環(huán)的取出一個(gè)個(gè)任務(wù)交給上述的并發(fā)線程池去執(zhí)行 
     */  
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();  
    //消息類型：發(fā)送結(jié)果  
    private static final int MESSAGE_POST_RESULT = 0x1;  
    //消息類型：更新進(jìn)度  
    private static final int MESSAGE_POST_PROGRESS = 0x2;  
    /**靜態(tài)Handler忌傻，用來(lái)發(fā)送上述兩種通知大脉，采用UI線程的Looper來(lái)處理消息 
     * 這就是為什么AsyncTask必須在UI線程調(diào)用，因?yàn)樽泳€程 
     * 默認(rèn)沒有Looper無(wú)法創(chuàng)建下面的Handler水孩，程序會(huì)直接Crash 
     */  
    private static final InternalHandler sHandler = new InternalHandler();  
    //默認(rèn)任務(wù)執(zhí)行器镰矿，被賦值為串行任務(wù)執(zhí)行器，就是它俘种，AsyncTask變成串行的了  
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;  
    //如下兩個(gè)變量我們先不要深究秤标，不影響我們對(duì)整體邏輯的理解  
    private final WorkerRunnable mWorker;  
    private final FutureTask mFuture;  
    //任務(wù)的狀態(tài) 默認(rèn)為掛起绝淡，即等待執(zhí)行，其類型標(biāo)識(shí)為易變的（volatile）  
    private volatile Status mStatus = Status.PENDING;  
    //原子布爾型苍姜，支持高并發(fā)訪問够委，標(biāo)識(shí)任務(wù)是否被取消  
    private final AtomicBoolean mCancelled = new AtomicBoolean();  
    //原子布爾型，支持高并發(fā)訪問怖现，標(biāo)識(shí)任務(wù)是否被執(zhí)行過  
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();  
  
    /*串行執(zhí)行器的實(shí)現(xiàn)茁帽，我們要好好看看，它是怎么把并行轉(zhuǎn)為串行的 
     *目前我們需要知道屈嗤，asyncTask.execute(Params ...)實(shí)際上會(huì)調(diào)用 
     *SerialExecutor的execute方法潘拨，這一點(diǎn)后面再說(shuō)明。也就是說(shuō)：當(dāng)你的asyncTask執(zhí)行的時(shí)候饶号， 
     *首先你的task會(huì)被加入到任務(wù)隊(duì)列铁追，然后排隊(duì)，一個(gè)個(gè)執(zhí)行 
     */  
    private static class SerialExecutor implements Executor {  
        //線性雙向隊(duì)列茫船，用來(lái)存儲(chǔ)所有的AsyncTask任務(wù)  
        final ArrayDeque mTasks = new ArrayDeque();  
        //當(dāng)前正在執(zhí)行的AsyncTask任務(wù)  
        Runnable mActive;  
  
        public synchronized void execute(final Runnable r) {  
            //將新的AsyncTask任務(wù)加入到雙向隊(duì)列中  
            mTasks.offer(new Runnable() {  
                public void run() {  
                    try {  
                        //執(zhí)行AsyncTask任務(wù)  
                        r.run();  
                    } finally {  
                        //當(dāng)前AsyncTask任務(wù)執(zhí)行完畢后琅束，進(jìn)行下一輪執(zhí)行，如果還有未執(zhí)行任務(wù)的話  
                        //這一點(diǎn)很明顯體現(xiàn)了AsyncTask是串行執(zhí)行任務(wù)的算谈，總是一個(gè)任務(wù)執(zhí)行完畢才會(huì)執(zhí)行下一個(gè)任務(wù)  
                        scheduleNext();  
                    }  
                }  
            });  
            //如果當(dāng)前沒有任務(wù)在執(zhí)行涩禀，直接進(jìn)入執(zhí)行邏輯  
            if (mActive == null) {  
                scheduleNext();  
            }  
        }  
  
        protected synchronized void scheduleNext() {  
            //從任務(wù)隊(duì)列中取出隊(duì)列頭部的任務(wù)，如果有就交給并發(fā)線程池去執(zhí)行  
            if ((mActive = mTasks.poll()) != null) {  
                THREAD_POOL_EXECUTOR.execute(mActive);  
            }  
        }  
    }  
  
    /** 
     * 任務(wù)的三種狀態(tài) 
     */  
    public enum Status {  
        /** 
         * 任務(wù)等待執(zhí)行 
         */  
        PENDING,  
        /** 
         * 任務(wù)正在執(zhí)行 
         */  
        RUNNING,  
        /** 
         * 任務(wù)已經(jīng)執(zhí)行結(jié)束 
         */  
        FINISHED,  
    }  
  
    /** 隱藏API：在UI線程中調(diào)用然眼，用來(lái)初始化Handler */  
    public static void init() {  
        sHandler.getLooper();  
    }  
  
    /** 隱藏API：為AsyncTask設(shè)置默認(rèn)執(zhí)行器 */  
    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() {  
            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);  
                }  
            }  
        };  
    }  
  
    private void postResultIfNotInvoked(Result result) {  
        final boolean wasTaskInvoked = mTaskInvoked.get();  
        if (!wasTaskInvoked) {  
            postResult(result);  
        }  
    }  
    //doInBackground執(zhí)行完畢艾船，發(fā)送消息  
    private Result postResult(Result result) {  
        @SuppressWarnings(unchecked)  
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
                new AsyncTaskResult(this, result));  
        message.sendToTarget();  
        return result;  
    }  
  
    /** 
     * 返回任務(wù)的狀態(tài) 
     */  
    public final Status getStatus() {  
        return mStatus;  
    }  
  
    /** 
     * 這個(gè)方法是我們必須要重寫的，用來(lái)做后臺(tái)計(jì)算 
     * 所在線程：后臺(tái)線程 
     */  
    protected abstract Result doInBackground(Params... params);  
  
    /** 
     * 在doInBackground之前調(diào)用高每，用來(lái)做初始化工作 
     * 所在線程：UI線程 
     */  
    protected void onPreExecute() {  
    }  
  
    /** 
     * 在doInBackground之后調(diào)用屿岂，用來(lái)接受后臺(tái)計(jì)算結(jié)果更新UI 
     * 所在線程：UI線程 
     */  
    protected void onPostExecute(Result result) {  
    }  
  
    /** 
     * Runs on the UI thread after {@link #publishProgress} is invoked. 
     /** 
     * 在publishProgress之后調(diào)用，用來(lái)更新計(jì)算進(jìn)度 
     * 所在線程：UI線程 
     */  
    protected void onProgressUpdate(Progress... values) {  
    }  
  
     /** 
     * cancel被調(diào)用并且doInBackground執(zhí)行結(jié)束鲸匿，會(huì)調(diào)用onCancelled爷怀，表示任務(wù)被取消 
     * 這個(gè)時(shí)候onPostExecute不會(huì)再被調(diào)用，二者是互斥的带欢，分別表示任務(wù)取消和任務(wù)執(zhí)行完成 
     * 所在線程：UI線程 
     */  
    @SuppressWarnings({UnusedParameters})  
    protected void onCancelled(Result result) {  
        onCancelled();  
    }      
      
    protected void onCancelled() {  
    }  
  
    public final boolean isCancelled() {  
        return mCancelled.get();  
    }  
  
    public final boolean cancel(boolean mayInterruptIfRunning) {  
        mCancelled.set(true);  
        return mFuture.cancel(mayInterruptIfRunning);  
    }  
  
    public final Result get() throws InterruptedException, ExecutionException {  
        return mFuture.get();  
    }  
  
    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,  
            ExecutionException, TimeoutException {  
        return mFuture.get(timeout, unit);  
    }  
  
    /** 
     * 這個(gè)方法如何執(zhí)行和系統(tǒng)版本有關(guān)运授，在AsyncTask的使用規(guī)則里已經(jīng)說(shuō)明，如果你真的想使用并行AsyncTask洪囤， 
     * 也是可以的徒坡，只要稍作修改 
     * 必須在UI線程調(diào)用此方法 
     */  
    public final AsyncTask execute(Params... params) {  
        //串行執(zhí)行  
        return executeOnExecutor(sDefaultExecutor, params);  
        //如果我們想并行執(zhí)行，這樣改就行了瘤缩，當(dāng)然這個(gè)方法我們沒法改  
        //return executeOnExecutor(THREAD_POOL_EXECUTOR, params);  
    }  
  
    /** 
     * 通過這個(gè)方法我們可以自定義AsyncTask的執(zhí)行方式喇完，串行or并行，甚至可以采用自己的Executor 
     * 為了實(shí)現(xiàn)并行剥啤，我們可以在外部這么用AsyncTask： 
     * asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, Params... params); 
     * 必須在UI線程調(diào)用此方法 
     */  
    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會(huì)最先執(zhí)行  
        onPreExecute();  
  
        mWorker.mParams = params;  
        //然后后臺(tái)計(jì)算#doInBackground才真正開始  
        exec.execute(mFuture);  
        //接著會(huì)有#onProgressUpdate被調(diào)用锦溪，最后是#onPostExecute  
  
        return this;  
    }  
  
    /** 
     * 這是AsyncTask提供的一個(gè)靜態(tài)方法不脯，方便我們直接執(zhí)行一個(gè)runnable 
     */  
    public static void execute(Runnable runnable) {  
        sDefaultExecutor.execute(runnable);  
    }  
  
    /** 
     * 打印后臺(tái)計(jì)算進(jìn)度，onProgressUpdate會(huì)被調(diào)用 
     */  
    protected final void publishProgress(Progress... values) {  
        if (!isCancelled()) {  
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,  
                    new AsyncTaskResult(this, values)).sendToTarget();  
        }  
    }  
  
    //任務(wù)結(jié)束的時(shí)候會(huì)進(jìn)行判斷刻诊，如果任務(wù)沒有被取消防楷，則onPostExecute會(huì)被調(diào)用  
    private void finish(Result result) {  
        if (isCancelled()) {  
            onCancelled(result);  
        } else {  
            onPostExecute(result);  
        }  
        mStatus = Status.FINISHED;  
    }  
  
    //AsyncTask內(nèi)部Handler，用來(lái)發(fā)送后臺(tái)計(jì)算進(jìn)度更新消息和計(jì)算完成消息  
    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;  
            }  
        }  
    }  
  
    private static abstract class WorkerRunnable implements Callable {  
        Params[] mParams;  
    }  
  
    @SuppressWarnings({RawUseOfParameterizedType})  
    private static class AsyncTaskResult {  
        final AsyncTask mTask;  
        final Data[] mData;  
  
        AsyncTaskResult(AsyncTask task, Data... data) {  
            mTask = task;  
            mData = data;  
        }  
    }  
}  

本人技術(shù)有限则涯，歡迎指正复局，謝謝！