前言

在Android開發中，內存泄露十分常見。本文將詳細講解內存泄露的其中一種情況：在Handler中發生的內存泄露

Anroid異步通信Handler系列文章
Android異步通信：Handler機制學習攻略
 Android異步通信：Handler使用教程
 Android異步通信：Handler工作原理
 Android異步通信：Handler源碼分析
 Android異步通信：詳解Handler內存泄露的原因

背景知識

內存泄露的定義：本該被回收的對象不能被回收而停留在堆內存中
內存泄露出現的原因：當一個對象已經不再被使用時，本該被回收但卻因為有另外一個正在使用的對象持有它的引用從而導致它不能被回收。這就導致了內存泄漏。

1. 問題描述

Handler的一般用法 = 新建Handler子類（內部類）、匿名Handler內部類，具體如下所示。

   /** 
     * 方式1：新建Handler子類（內部類）
     */  
    public class MainActivity extends AppCompatActivity {

            public static final String TAG = "carson：";
            private Handler showhandler;

            // 主線程創建時便自動創建Looper & 對應的MessageQueue
            // 之后執行Loop()進入消息循環
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);

                //1. 實例化自定義的Handler類對象->>分析1
                //注：此處并無指定Looper，故自動綁定當前線程(主線程)的Looper、MessageQueue
                showhandler = new FHandler();

                // 2. 啟動子線程1
                new Thread() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        // a. 定義要發送的消息
                        Message msg = Message.obtain();
                        msg.what = 1;// 消息標識
                        msg.obj = "AA";// 消息存放
                        // b. 傳入主線程的Handler & 向其MessageQueue發送消息
                        showhandler.sendMessage(msg);
                    }
                }.start();

                // 3. 啟動子線程2
                new Thread() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        // a. 定義要發送的消息
                        Message msg = Message.obtain();
                        msg.what = 2;// 消息標識
                        msg.obj = "BB";// 消息存放
                        // b. 傳入主線程的Handler & 向其MessageQueue發送消息
                        showhandler.sendMessage(msg);
                    }
                }.start();

            }

            // 分析1：自定義Handler子類
            class FHandler extends Handler {

                // 通過復寫handlerMessage() 從而確定更新UI的操作
                @Override
                public void handleMessage(Message msg) {
                    switch (msg.what) {
                        case 1:
                            Log.d(TAG, "收到線程1的消息");
                            break;
                        case 2:
                            Log.d(TAG, " 收到線程2的消息");
                            break;


                    }
                }
            }
        }

   /** 
     * 方式2：匿名Handler內部類
     */ 
     public class MainActivity extends AppCompatActivity {

        public static final String TAG = "carson：";
        private Handler showhandler;

        // 主線程創建時便自動創建Looper & 對應的MessageQueue
        // 之后執行Loop()進入消息循環
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            //1. 通過匿名內部類實例化的Handler類對象
            //注：此處并無指定Looper，故自動綁定當前線程(主線程)的Looper、MessageQueue
            showhandler = new  Handler(){
                // 通過復寫handlerMessage()從而確定更新UI的操作
                @Override
                public void handleMessage(Message msg) {
                        switch (msg.what) {
                            case 1:
                                Log.d(TAG, "收到線程1的消息");
                                break;
                            case 2:
                                Log.d(TAG, " 收到線程2的消息");
                                break;
                        }
                    }
            };

            // 2. 啟動子線程1
            new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // a. 定義要發送的消息
                    Message msg = Message.obtain();
                    msg.what = 1;// 消息標識
                    msg.obj = "AA";// 消息存放
                    // b. 傳入主線程的Handler & 向其MessageQueue發送消息
                    showhandler.sendMessage(msg);
                }
            }.start();

            // 3. 啟動子線程2
            new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // a. 定義要發送的消息
                    Message msg = Message.obtain();
                    msg.what = 2;// 消息標識
                    msg.obj = "BB";// 消息存放
                    // b. 傳入主線程的Handler & 向其MessageQueue發送消息
                    showhandler.sendMessage(msg);
                }
            }.start();

        }
}

測試結果

示意圖

上述例子雖可運行成功，但代碼會出現嚴重警告：

警告的原因 = 該Handler類由于無設置為靜態類，從而導致了內存泄露

最終的內存泄露發生在Handler類的外部類：MainActivity類

示意圖

那么，該Handler在無設置為靜態類時，為什么會造成內存泄露呢？

2. 原因講解

2.1 儲備知識

主線程的Looper對象的生命周期 = 該應用程序的生命周期
在Java中，非靜態內部類 & 匿名內部類都默認持有外部類的引用

2.2 泄露原因描述

從上述示例代碼可知：

上述的Handler實例的消息隊列有2個分別來自線程1、2的消息（分別延遲1s、6s）
在Handler消息隊列還有未處理的消息 / 正在處理消息時，消息隊列中的Message持有Handler實例的引用
由于Handler = 非靜態內部類 / 匿名內部類（2種使用方式），故又默認持有外部類的引用（即MainActivity實例），引用關系如下圖：

示意圖

上述的引用關系會一直保持，直到Handler消息隊列中的所有消息被處理完畢。在Handler消息隊列還有未處理的消息 / 正在處理消息時，此時若需銷毀外部類MainActivity，但由于上述引用關系，垃圾回收器（GC）無法回收MainActivity，從而造成內存泄漏。如下圖：

示意圖

2.3 總結

當Handler消息隊列還有未處理的消息 / 正在處理消息時，存在引用關系： “未被處理 / 正處理的消息 -> Handler實例 -> 外部類”
若出現 Handler的生命周期 > 外部類的生命周期時（即 Handler消息隊列還有未處理的消息 / 正在處理消息而外部類需銷毀時），將使得外部類無法被垃圾回收器（GC）回收，從而造成內存泄露

3. 解決方案

從上面可看出，造成內存泄露的原因有2個關鍵條件：

存在 “未被處理 / 正處理的消息 -> Handler實例 -> 外部類” 的引用關系
Handler的生命周期 > 外部類的生命周期

即 Handler消息隊列還有未處理的消息 / 正在處理消息而外部類需銷毀

解決方案的思路 = 使得上述任1條件不成立即可。

解決方案1：靜態內部類

原理：靜態內部類不默認持有外部類的引用，從而使得 “未被處理 / 正處理的消息 -> Handler實例 -> 外部類” 的引用關系不存在。
具體方案：將Handler的子類設置成靜態內部類。此外，還可使用WeakReference弱引用持有外部類，保證外部類能被回收。因為：弱引用的對象擁有短暫的生命周期，在垃圾回收器線程掃描時，一旦發現了具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存
解決代碼

public class MainActivity extends AppCompatActivity {

    public static final String TAG = "carson：";
    private Handler showhandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 實例化自定義的Handler類對象->>分析1
        // 注：
            // a. 此處并無指定Looper，故自動綁定當前線程(主線程)的Looper、MessageQueue；
            // b. 定義時需傳入持有的Activity實例（弱引用）
        showhandler = new FHandler(this);

        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // a. 定義要發送的消息
                Message msg = Message.obtain();
                msg.what = 1;// 消息標識
                msg.obj = "AA";// 消息存放

                showhandler.sendMessage(msg);
            }
        }.start();

    }

    // 設置為：靜態內部類
    private static class FHandler extends Handler{

        // 定義 弱引用實例
        private WeakReference<Activity> reference;

        // 在構造方法中傳入需持有的Activity實例
        public FHandler(Activity activity) {
            // 使用WeakReference弱引用持有Activity實例
            reference = new WeakReference<Activity>(activity); }

        // 通過復寫handlerMessage() 從而確定更新UI的操作
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    Log.d(TAG, "收到線程1的消息");
                    break;
                case 2:
                    Log.d(TAG, " 收到線程2的消息");
                    break;


            }
        }
    }
}

解決方案2：當外部類結束生命周期時，清空Handler內消息隊列

原理：不僅使得 “未被處理 / 正處理的消息 -> Handler實例 -> 外部類” 的引用關系不復存在，同時使得 Handler的生命周期（即消息存在的時期）與外部類的生命周期同步
具體方案：當外部類（此處以Activity為例）結束生命周期時（此時系統會調用onDestroy（）），清除 Handler消息隊列里的所有消息（調用removeCallbacksAndMessages(null)）
具體代碼

@Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);
        // 外部類Activity生命周期結束時，同時清空消息隊列 & 結束Handler生命周期
    }

使用建議

為了保證Handler中消息隊列中的所有消息都能被執行，此處推薦使用解決方案1解決內存泄露問題，即 靜態內部類 + 弱引用的方式

4. 總結

本文主要講解了 Handler 造成內存泄露的相關知識：原理 & 解決方案
下一篇文章我將對講解Android Handler的相關知識，感興趣的同學可以繼續關注Carson_Ho的簡書

Anroid異步通信Handler系列文章
Android異步通信：Handler機制學習攻略
 Android異步通信：Handler使用教程
 Android異步通信：Handler工作原理
 Android異步通信：Handler源碼分析
 Android異步通信：詳解Handler內存泄露的原因

歡迎關注Carson_Ho的簡書

不定期分享關于安卓開發的干貨，追求短、平、快，但卻不缺深度。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Android異步通信：詳解 Handler 內存泄露的原因

Android異步通信：詳解 Handler 內存泄露的原因

前言

目錄

背景知識

1. 問題描述

2. 原因講解

2.1 儲備知識

2.2 泄露原因描述

2.3 總結

3. 解決方案

解決方案1：靜態內部類

解決方案2：當外部類結束生命周期時，清空Handler內消息隊列

使用建議

4. 總結

歡迎關注Carson_Ho的簡書

請點贊！因為你的鼓勵是我寫作的最大動力！

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Android異步通信：詳解 Handler 內存泄露的原因

前言

目錄

背景知識

1. 問題描述

2. 原因講解

2.1 儲備知識

2.2 泄露原因描述

2.3 總結

3. 解決方案

解決方案1：靜態內部類

解決方案2：當外部類結束生命周期時，清空Handler內消息隊列

使用建議

4. 總結

歡迎關注Carson_Ho的簡書

請點贊！因為你的鼓勵是我寫作的最大動力！

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频