性能優化8--記憶體泄露_ZenDei技術網路在線

一.根源：記憶體泄露簡單說就是已經沒有用的資源，但是由於被其他資源引用著無法被GC銷毀。二.記憶體泄露常見場景 1.單例導致記憶體泄露單例的靜態特性使得它的生命周期同應用的生命周期一樣長，如果一個對象已經沒有用處了，但是單例還持有它的引用，那麼在整個應用程式的生命周期它都不能正常被回收，從而導致記憶體 ...

一.根源：

　　記憶體泄露簡單說就是已經沒有用的資源，但是由於被其他資源引用著無法被GC銷毀。

二.記憶體泄露常見場景

1.單例導致記憶體泄露

   單例的靜態特性使得它的生命周期同應用的生命周期一樣長，如果一個對象已經沒有用處了，但是單例還持有它的引用，那麼在整個應用程式的生命周期它都不能正常被回收，從而導致記憶體泄露。
public class AppSettings {

    private static AppSettings sInstance;
    private Context mContext;

    private AppSettings(Context context) {
        this.mContext = context;
    }

    public static AppSettings getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new AppSettings(context);
        }
        return sInstance;
    }
}
    以Activity為例，當我們啟動一個Activity，並調用getInstance(Context context)方法去獲取AppSettings的單例，傳入Activity.this作為context，這樣AppSettings類的單例sInstance就持有了Activity的引用，當我們退出Activity時，該Activity就沒有用了，但是因為sIntance作為靜態單例（在應用程式的整個生命周期中存在）會繼續持有這個Activity的引用，導致這個Activity對象無法被回收釋放，這就造成了記憶體泄露。
    為了避免這樣單例導致記憶體泄露，我們可以將context參數改為全局的上下文：
private AppSettings(Context context) {
    this.mContext = context.getApplicationContext();
}
    全局的上下文Application Context就是應用程式的上下文，和單例的生命周期一樣長，這樣就避免了記憶體泄漏。
    單例模式對應應用程式的生命周期，所以我們在構造單例的時候儘量避免使用Activity的上下文，而是使用Application的上下文

View Code

2.靜態變數導致記憶體泄露

靜態變數存儲在方法區，它的生命周期從類載入開始，到整個進程結束。一旦靜態變數初始化後，它所持有的引用只有等到進程結束才會釋放。

比如下麵這樣的情況，在Activity中為了避免重覆的創建info，將sInfo作為靜態變數：
public class MainActivity extends AppCompatActivity {

    private static Info sInfo;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        if (sInfo != null) {
            sInfo = new Info(this);
        }
    }
}

class Info {
    public Info(Activity activity) {
    }
}

Info作為Activity的靜態成員，並且持有Activity的引用，但是sInfo作為靜態變數，生命周期肯定比Activity長。所以當Activity退出後，sInfo仍然引用了Activity，Activity不能被回收，這就導致了記憶體泄露。

在Android開發中，靜態持有很多時候都有可能因為其使用的生命周期不一致而導致記憶體泄露，所以我們在新建靜態持有的變數的時候需要多考慮一下各個成員之間的引用關係，並且儘量少地使用靜態持有的變數，以避免發生記憶體泄露。當然，我們也可以在適當的時候講靜態量重置為null，使其不再持有引用，這樣也可以避免記憶體泄露。

View Code

3.非靜態內部類導致記憶體泄露

非靜態內部類（包括匿名內部類）預設就會持有外部類的引用，當非靜態內部類對象的生命周期比外部類對象的生命周期長時，就會導致記憶體泄露。

非靜態內部類導致的記憶體泄露在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) {
                // 做相應邏輯
            }
        }
    };
}

熟悉Handler消息機制的都知道，mHandler會作為成員變數保存在發送的消息msg中，即msg持有mHandler的引用，而mHandler是Activity的非靜態內部類實例，即mHandler持有Activity的引用，那麼我們就可以理解為msg間接持有Activity的引用。msg被髮送後先放到消息隊列MessageQueue中，然後等待Looper的輪詢處理（MessageQueue和Looper都是與線程相關聯的，MessageQueue是Looper引用的成員變數，而Looper是保存在ThreadLocal中的）。那麼當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就會回收並釋放所占據的記憶體單元。這樣就不會發生記憶體泄露了。

上面的做法確實避免了Activity導致的記憶體泄露，發送的msg不再已經沒有持有Activity的引用了，但是msg還是有可能存在消息隊列MessageQueue中，所以更好的是在Activity銷毀時就將mHandler的回調和發送的消息給移除掉。

@Override
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的正確寫法）

View Code

4.未取消註冊或回調導致記憶體泄露

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

ublic 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註冊網路請求的觀察者回調，同樣作為匿名內部類持有外部引用，所以需要記得在不用或者銷毀的時候取消註冊

View Code

5.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，以避免發生記憶體泄漏。

View Code

6.集合中的對象未清理造成記憶體泄露

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

View Code

7.資源未關閉或釋放導致記憶體泄露

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

View Code

8.屬性動畫造成記憶體泄露

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

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

View Code

9.WebView造成記憶體泄露

https://www.jianshu.com/p/3e8f7dbb0dc7

關於WebView的記憶體泄露，因為WebView在載入網頁後會長期占用記憶體而不能被釋放，因此我們在Activity銷毀後要調用它的destory()方法來銷毀它以釋放記憶體。

另外在查閱WebView記憶體泄露相關資料時看到這種情況：

Webview下麵的Callback持有Activity引用，造成Webview記憶體無法釋放，即使是調用了Webview.destory()等方法都無法解決問題（Android5.1之後）。

最終的解決方案是：在銷毀WebView之前需要先將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();
}

View Code

三.優化方案

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