Android常見內存泄漏及優化總結

前言

最近在整理回顧零碎知識點，今天整理下Android內存優化方案分享給大家。

在Android開發中，一些不好的編程習慣會導致我們的開發的app存在內存泄露的情況。下面簡單介紹一些在Android開發中常見的內存泄露場景及優化方案。

1.單例導致內存泄露

單例模式在Android開發中會經常用到，但是如果使用不當就會導致內存泄露。因爲單例的靜態特性使得它的生命週期同應用的生命週期一樣長，如果一個對象已經沒有用處了，但是單例還持有它的引用，那麼在整個應用程序的生命週期它都不能正常被回收，從而導致內存泄露。

public class Singleton {
    private static Singleton singleton = null;
    private Context mContext;

    public Singleton(Context mContext) {
        this.mContext = mContext;
    }

    public static Singleton getSingleton(Context context){
        if (null == singleton){
            singleton = new Singleton(context);
        }
        return singleton;
    }
}

像上面代碼中這樣的單例，如果我們在調用getInstance(Context context)方法的時候傳入的context參數是Activity、Service等上下文，就會導致內存泄露。

當我們退出Activity時，該Activity就沒有用了，但是因爲singleton作爲靜態單例（在應用程序的整個生命週期中存在）會繼續持有這個Activity的引用，導致這個Activity對象無法被回收釋放，這就造成了內存泄露。

爲了避免這樣單例導致內存泄露，我們可以將context參數改爲全局的上下文：

public Singleton(Context mContext) {
        this.mContext = mContext.getApplicationContext();
    }

全局的上下文Application Context就是應用程序的上下文，和單例的生命週期一樣長，這樣就避免了內存泄漏。單例模式對應應用程序的生命週期，所以我們在構造單例的時候儘量避免使用Activity的上下文，而是使用Application的上下文。

2.非靜態內部類導致內存泄露

非靜態內部類（包括匿名內部類）默認就會持有外部類的引用，當非靜態內部類對象的生命週期比外部類對象的生命週期長時，就會導致內存泄露。

非靜態內部類導致的內存泄露在Android開發中有一種典型的場景就是使用Handler，很多開發者在使用Handler是這樣寫的：

public class MainActivity extends AppCompatActivity {

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

    private void start() {
        Message msg = Message.obtain();
        msg.what = 1;
        mHandler.sendMessage(msg);
    }

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 1) {
                // 做相應邏輯
            }
        }
    };
}

當Activity退出後，msg可能仍然存在於消息對列MessageQueue中未處理或者正在處理，那麼這樣就會導致Activity無法被回收，以致發生Activity的內存泄露。

通常在Android開發中如果要使用內部類，但又要規避內存泄露，一般都會採用靜態內部類+弱引用的方式。

public class MainActivity extends AppCompatActivity {

    private Handler mHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mHandler = new MyHandler(this);
        start();
    }

    private void start() {
        Message msg = Message.obtain();
        msg.what = 1;
        mHandler.sendMessage(msg);
    }

    private static class MyHandler extends Handler {

        private WeakReference<MainActivity> activityWeakReference;

        public MyHandler(MainActivity activity) {
            activityWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            MainActivity activity = activityWeakReference.get();
            if (activity != null) {
                if (msg.what == 1) {
                    // 做相應邏輯
                }
            }
        }
    }
}

mHandler通過弱引用的方式持有Activity，當GC執行垃圾回收時，遇到Activity就會回收並釋放所佔據的內存單元。這樣就不會發生內存泄露了。

protected void onDestroy() {
    super.onDestroy();
    mHandler.removeCallbacksAndMessages(null);
}

內部類造成內存泄露還有一種情況就是使用Thread或者AsyncTask。

比如在Activity中直接new一個子線程Thread：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 模擬相應耗時邏輯
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

或者直接新建AsyncTask異步任務：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... params) {
                // 模擬相應耗時邏輯
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }.execute();
    }
}

這種方式新建的子線程Thread和AsyncTask都是匿名內部類對象，默認就隱式的持有外部Activity的引用，導致Activity內存泄露。要避免內存泄露的話還是需要像上面Handler一樣使用靜態內部類+弱應用的方式（代碼就不列了，參考上面Hanlder的正確寫法）。

3.未取消註冊或回調導致內存泄露

比如我們在Activity中註冊廣播，如果在Activity銷燬後不取消註冊，那麼這個剛播會一直存在系統中，同上面所說的非靜態內部類一樣持有Activity引用，導致內存泄露。因此註冊廣播後在Activity銷燬後一定要取消註冊。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        this.registerReceiver(mReceiver, new IntentFilter());
    }

    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 接收到廣播需要做的邏輯
        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        this.unregisterReceiver(mReceiver);
    }
}

在註冊觀察則模式的時候，如果不及時取消也會造成內存泄露。比如使用Retrofit+RxJava註冊網絡請求的觀察者回調，同樣作爲匿名內部類持有外部引用，所以需要記得在不用或者銷燬的時候取消註冊。

4.Timer和TimerTask導致內存泄露

Timer和TimerTask在Android中通常會被用來做一些計時或循環任務，比如實現無限輪播的ViewPager：

public class MainActivity extends AppCompatActivity {

    private ViewPager mViewPager;
    private PagerAdapter mAdapter;
    private Timer mTimer;
    private TimerTask mTimerTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
        mTimer.schedule(mTimerTask, 3000, 3000);
    }

    private void init() {
        mViewPager = (ViewPager) findViewById(R.id.view_pager);
        mAdapter = new ViewPagerAdapter();
        mViewPager.setAdapter(mAdapter);

        mTimer = new Timer();
        mTimerTask = new TimerTask() {
            @Override
            public void run() {
                MainActivity.this.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        loopViewpager();
                    }
                });
            }
        };
    }

    private void loopViewpager() {
        if (mAdapter.getCount() > 0) {
            int curPos = mViewPager.getCurrentItem();
            curPos = (++curPos) % mAdapter.getCount();
            mViewPager.setCurrentItem(curPos);
        }
    }

    private void stopLoopViewPager() {
        if (mTimer != null) {
            mTimer.cancel();
            mTimer.purge();
            mTimer = null;
        }
        if (mTimerTask != null) {
            mTimerTask.cancel();
            mTimerTask = null;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        stopLoopViewPager();
    }
}

當我們Activity銷燬的時，有可能Timer還在繼續等待執行TimerTask，它持有Activity的引用不能被回收，因此當我們Activity銷燬的時候要立即cancel掉Timer和TimerTask，以避免發生內存泄漏。

5.集合中的對象未清理造成內存泄露

這個比較好理解，如果一個對象放入到ArrayList、HashMap等集合中，這個集合就會持有該對象的引用。當我們不再需要這個對象時，也並沒有將它從集合中移除，這樣只要集合還在使用（而此對象已經無用了），這個對象就造成了內存泄露。並且如果集合被靜態引用的話，集合裏面那些沒有用的對象更會造成內存泄露了。所以在使用集合時要及時將不用的對象從集合remove，或者clear集合，以避免內存泄漏。

6.資源未關閉或釋放導致內存泄露

在使用IO、File流或者Sqlite、Cursor等資源時要及時關閉。這些資源在進行讀寫操作時通常都使用了緩衝，如果及時不關閉，這些緩衝對象就會一直被佔用而得不到釋放，以致發生內存泄露。因此我們在不需要使用它們的時候就及時關閉，以便緩衝能及時得到釋放，從而避免內存泄露。

7.屬性動畫造成內存泄露

動畫同樣是一個耗時任務，比如在Activity中啓動了屬性動畫（ObjectAnimator），但是在銷燬的時候，沒有調用cancle方法，雖然我們看不到動畫了，但是這個動畫依然會不斷地播放下去，動畫引用所在的控件，所在的控件引用Activity，這就造成Activity無法正常釋放。因此同樣要在Activity銷燬的時候cancel掉屬性動畫，避免發生內存泄漏。

@Override
protected void onDestroy() {
    super.onDestroy();
    mAnimator.cancel();
}

8.WebView造成內存泄露

關於WebView的內存泄露，因爲WebView在加載網頁後會長期佔用內存而不能被釋放，因此我們在Activity銷燬後要調用它的destory()方法來銷燬它以釋放內存。

最終的解決方案是：在銷燬WebView之前需要先將WebView從父容器中移除，然後在銷燬WebView。

@Override
protected void onDestroy() {
    super.onDestroy();
    // 先從父控件中移除WebView
    mWebViewContainer.removeView(mWebView);
    mWebView.stopLoading();
    mWebView.getSettings().setJavaScriptEnabled(false);
    mWebView.clearHistory();
    mWebView.removeAllViews();
    mWebView.destroy();
}

內存優化

1.檢測內存泄漏的工具

1.LeakCanary

2.Android Studio profile

3.MAT

2.圖片壓縮

1. bitmap 壓縮
大家都知道 bitmap 佔用內存很大，用完之後要 recycle 一下。不知道大家有沒有用過，圖片加載出來內存就爆掉了（OOM）情況。首先一張圖片從網絡獲下來，從 InputStream 轉成 Bitmap，這個 bitmap 佔了多少內存怎麼計算？獻上代碼：
Bitmap.getAllocationByteCount();

其實就是 ByteCount = 長* 寬 * 4（假設這裏每一個像素點是是RGB888） 那就是 4 個字節。也有一個像素點 RGB565 佔 3 個字節,當然佔更多字節的 RGB888 更加高清無碼。起初版本 Glide 使用 RGB565，目前 Glide4.XX 的默認都是 RGB888，當然自己可以配置一下。

爲了解決這個問題一般都是通過下面代碼：

BitmapFactory.Options options = new BitmapFactory.Options();  
options.inJustDecodeBounds = true;  
// 通過這個bitmap獲取圖片的寬和高 
Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/MTXX/3.jpg", options); 
float realWidth = options.outWidth;  
float realHeight = options.outHeight;
//計算出scale
options.inSampleSize = scale;  
options.inJustDecodeBounds = false;  
// 注意這次要把options.inJustDecodeBounds 設爲 false,這次圖片是要讀取出來的。
bitmap = BitmapFactory.decodeFile("/sdcard/MTXX/3.jpg", options);  

先獲取他的圖片大小，根據自己需要的大小計算出縮放比例。（圖片大小都是放在圖片的頭部，這時候不會去加載整張圖片）進行縮放，得出符合自己的控件尺寸的大小。（當然還有些非法的圖片頭部是獲取不出 長* 寬。這時候記得搞個默認的縮放率，防止 OOM）有時候爲了優化內存，還不如壓縮一張圖片 所節約的內存來的更快。譬如 一張 1080 * 1920 圖片再乘以 4 等於 7.9 M。我壓縮到 一張縮略圖 200*200 等於 156KB。瞬間節約了7M 空間。

總結

內存泄露在Android內存優化是一個比較重要的一個方面，很多時候程序中發生了內存泄露我們不一定就能注意到，所有在編碼的過程要養成良好的習慣。總結下來只要做到以下這幾點就能避免大多數情況的內存泄漏：

1.構造單例的時候儘量別用Activity的引用；
2.靜態引用時注意應用對象的置空或者少用靜態引用；
3.使用靜態內部類+軟引用代替非靜態內部類；
4.及時取消廣播或者觀察者註冊；
5.耗時任務、屬性動畫在Activity銷燬時記得cancel；
6.文件流、Cursor等資源及時關閉；
7.Activity銷燬時WebView的移除和銷燬。