以我現在的認識，造成記憶體洩漏的原因，往大了說，無非就是一些特殊的原因導致Activity在該銷燬的時候無法被銷燬，而AsyncTask在建立的時候會持有當前Activity的引用，所以也有可能導致記憶體洩漏！因為在上篇關於AsyncTask的介紹中，對AsyncTask的講解還算詳細，在介紹本篇的時候，為了方便讀者的理解，可能有些地方還是要重複提到一些，有些有些地方我打算一筆帶過，不做過多的解釋。讀者有哪裡不明白的話，還請參考一下上篇關於AsyncTask的部落格，謝謝！！！

       在解釋造成記憶體洩漏的原因之前，首先要先稍微提一下，AsyncTask是怎麼持有外部類，也就是Activity的引用的。這裡有一個CSDN部落格的連結，解釋了原因是什麼:

點選開啟連結    ，感謝博主！！！

       簡單的說，當我們以內部類的形式構造AsyncTask物件的時候，編譯期會自動為AsyncTask的構造方法增加一個外部類型別的引數，同時在內部類增加一個外部類型別的成員變數，當呼叫構造方法構造AsyncTask物件的時候，會預設傳入外部類的引用作為引數，併為內部類的中外部類型別的成員變數賦值，這樣的話內部類就持有了外部類的引用。

       我們知道，AsyncTask的任務是通過execute()方法為入口執行的，以下是execute()方法的程式碼

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

我們可以看到在execute()方法中呼叫了executeOnExecutor()方法，並傳入了兩個引數，一個是序列的執行緒池，一個是我們傳入的引數，以下是executeOnExecutor()方法:

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

在上述程式碼中，exec.execute(mFuture)，也就是已mFuture為引數，執行這個序列執行緒池的execute()方法，其中mFuture是一個FutureTask的物件，是在AsyncTask的構造方法中構造的，我們來看一下AsyncTask構造方法的程式碼:

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

                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                Result result = doInBackground(mParams);
                Binder.flushPendingCommands();
                return postResult(result);
            }
        };

        mFuture = new FutureTask<Result>(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 occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

       我們可以看到，在AsyncTask的構造方法中，在構造mFuture物件的時候，呼叫了postResultIfNotInvoked()這個方法，該方法是AsyncTask內部的方法，所以此時mFuture與AsyncTask關聯了起來，即mFuture物件持有了AsyncTask的引用，而AsyncTask持有Activity的引用，所以，mFuture間接的持有Activity的引用，而在executeOnExecutor()方法中，序列的執行緒池的物件exec,也就是從execute()方法中傳遞過來的sDefaultExecutor物件，以mFuture為引數執行了execute()方法，即exec.execute(mFuture),所以這個序列執行緒池的物件sDefaultExecutor持有了mFuture物件的引用，因為mFuture物件間接的持有了Activity的物件，所以sDefaultExecutor也間接的持有了Activity物件。下面我們再來看這個序列執行緒池的execute()方法:

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

我們可以看到，在這個序列執行緒池對應的類是靜態的，所以不會被銷燬，在這個類的內部維護了一個mTasks佇列，在這個序列執行緒池的execute()方法中，會將傳遞過來的Runnable新增到mTasks佇列中，這個Runnable物件也就是我們傳遞過來的mFuture物件。所以mTask物件持有了mFuture的物件，所以也間接的斥持有了Activity的物件，並且在execute()方法中會通過scheduleNext()去執行Runnable任務，我們可以看到，在scheduleNext()中，會先通過mTasks.poll()方法把佇列頭部的Runnable取出，並且賦給mActive，此時的mActive就相當於新增到mTasks佇列中的Runnable，也可以當做mFuture，所以，mActive也持有Activity物件，THREAD_POOL_EXECUTOR也是一個執行緒池，用於執行任務，所以當THREAD_POOL_EXECUTOR.execute(mActive)，也就是這個執行緒池以mActivie為引數去執行任務的時候，同時持有了mActive的物件，也就間接的持有了Activity物件,下面給出THREAD_POOL_EXECUTOR這個執行緒池的相關程式碼:

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

我們可以看出，這個執行緒池也是靜態的，所以也是不被銷燬的，也就是說，只要任務沒有執行完畢，上述的兩個執行緒池都會一直持有Activity的物件，這個時候我們就可以想到，假如在AsyncTask任務沒有執行完畢的時候就去銷燬Activity，因為AsyncTask任務沒有執行完畢，所以執行緒池會一直持有該物件，也就是一直間接的持有Activity的物件，這樣的話就會導致記憶體洩漏。

（最近有不少時間沒有發部落格了，因為從上家公司實習結束回到學校之後就鄰近畢業了，從三月下旬開始就一直在忙畢業相關的事情，現在剛剛入職一家比較知名的網際網路公司，一直在忙著熟悉公司的專案，沒太有時間寫部落格，以後會慢慢的把寫部落格拾起來，額，剛剛看了之前寫的僅有的幾篇部落格，感覺寫部落格真是個不錯的習慣，就像記筆記一樣，不太記得的地方可以隨時翻過來看看）