韓夢飛沙 yue31313 韓亞飛 han_meng_fei_sha 313134555@qq.com
內存泄漏檢測工具
android 內存泄漏檢測工具
========
內存泄漏 就是 無用的對象沒有被回收，占用着內存，使得可用內存變小了。
如何檢測內存泄漏, 可以使用 LeakCanary來檢測內存泄漏。
leak 是 泄漏的意思。.
Canary 是 金絲雀 的意思。
在運行 應用的時候， 泄漏金絲雀 如果檢測到內存泄漏 會顯示一個通知。
========
LeakCanary捕獲常見內存泄漏以及解決辦法
1.）錯誤使用單例造成的內存泄漏
在平時開發中單例設計模式是我們經常使用的一種設計模式，而在開發中單例經常需要持有Context對象，如果持有的Context對象生命周期與單例生命周期更短時，或導致Context無法被釋放回收，則有可能造成內存泄漏，錯誤寫法如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public
class
LoginManager {
private
static
LoginManager mInstance;
private
Context mContext;
private
LoginManager(Context context) {
this
.mContext = context;
}
public
static
LoginManager getInstance(Context context) {
if
(mInstance ==
null
) {
synchronized
(LoginManager.
class
) {
if
(mInstance ==
null
) {
mInstance =
new
LoginManager(context);
}
}
}
return
mInstance;
}
public
void
dealData() {
}
}
|
若我們在一個Activity中調用的，然后關閉該Activity則會出現內存泄漏。
|
1
|
LoginManager.getInstance(
this
).dealData();
|
LeakCanary檢測結果如下：
解決 辦法要保證Context和AppLication的生命周期一樣，修改后代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public
class
LoginManager {
private
static
LoginManager mInstance;
private
Context mContext;
private
LoginManager(Context context) {
this
.mContext = context.getApplicationContext();
}
public
static
LoginManager getInstance(Context context) {
if
(mInstance ==
null
) {
synchronized
(LoginManager.
class
) {
if
(mInstance ==
null
) {
mInstance =
new
LoginManager(context);
}
}
}
return
mInstance;
}
public
void
dealData() {
}
}
|
2.）Handler造成的內存泄漏
早些年Handler的使用頻率還是蠻高的，它是工作線程與UI線程之間通訊的橋梁，只是現在大量開源框架對其進行了封裝，我們這里模擬一種常見使用方式來模擬內存泄漏情形。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public
class
MainActivity
extends
AppCompatActivity {
private
Handler mHandler =
new
Handler();
private
TextView mTextView;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.text);
//模擬內存泄露
mHandler.postDelayed(
new
Runnable() {
@Override
public
void
run() {
mTextView.setText(
"lcj"
);
}
},
3
*
60
*
1000
);
finish();
}
@Override
protected
void
onDestroy() {
super
.onDestroy();
LApplication.getRefWatcher().watch(
this
);
}
}
|
上述代碼通過內部類的方式創建mHandler對象,此時mHandler會隱式地持有一個外部類對象引用這里就是MainActivity，當執行postDelayed方法時，該方法會將你的Handler裝入一個Message，並把這條Message推到MessageQueue中，MessageQueue是在一個Looper線程中不斷輪詢處理消息，那么當這個Activity退出時消息隊列中還有未處理的消息或者正在處理消息，而消息隊列中的Message持有mHandler實例的引用，mHandler又持有Activity的引用，所以導致該Activity的內存資源無法及時回收，引發內存泄漏。
LeakCanary檢測結果如下：
要想避免Handler引起內存泄漏問題，需要我們在Activity關閉退出的時候的移除消息隊列中所有消息和所有的Runnable。上述代碼只需在onDestroy()函數中調用mHandler.removeCallbacksAndMessages(null);就行了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public
class
MainActivity1
extends
AppCompatActivity {
private
Handler mHandler =
new
Handler();
private
TextView mTextView;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.text);
//模擬內存泄露
mHandler.postDelayed(
new
Runnable() {
@Override
public
void
run() {
mTextView.setText(
"lcj"
);
}
},
3
*
60
*
1000
);
finish();
}
@Override
protected
void
onDestroy() {
super
.onDestroy();
mHandler.removeCallbacksAndMessages(
null
);
mHandler=
null
;
LApplication.getRefWatcher().watch(
this
);
}
}
|
3.)線程造成的內存泄漏
最早時期的時候處理耗時操作多數都是采用Thread+Handler的方式，后來逐步被AsyncTask取代，直到現在采用RxJava的方式來處理異步。這里以AsyncTask為例，可能大部分人都會這樣處理一個耗時操作然后通知UI更新結果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public
class
MainActivity
extends
AppCompatActivity {
private
AsyncTask<Void, Void, Integer> asyncTask;
private
TextView mTextView;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.text);
testAsyncTask();
finish();
}
private
void
testAsyncTask() {
asyncTask =
new
AsyncTask<Void, Void, Integer>() {
@Override
protected
Integer doInBackground(Void... params) {
int
i =
0
;
//模擬耗時操作
while
(!isCancelled()) {
i++;
if
(i >
1000000000
) {
break
;
}
Log.e(
"LeakCanary"
,
"asyncTask---->"
+ i);
}
return
i;
}
@Override
protected
void
onPostExecute(Integer integer) {
super
.onPostExecute(integer);
mTextView.setText(String.valueOf(integer));
}
};
asyncTask.execute();
}
@Override
protected
void
onDestroy() {
super
.onDestroy();
LApplication.getRefWatcher().watch(
this
);
}
}
|
對於上面的例子來說，在處理一個比較耗時的操作時，可能還沒處理結束MainActivity就執行了退出操作，但是此時AsyncTask依然持有對MainActivity的引用就會導致MainActivity無法釋放回收引發內存泄漏。
LeakCanary檢測結果：
如何解決這種內存泄漏呢？在使用AsyncTask時，在Activity銷毀時候也應該取消相應的任務AsyncTask.cancel()方法，避免任務在后台執行浪費資源，進而避免內存泄漏的發生。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
public
class
MainActivity3
extends
AppCompatActivity {
private
AsyncTask<Void, Void, Integer> asyncTask;
private
TextView mTextView;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.text);
testAsyncTask();
finish();
}
private
void
testAsyncTask() {
asyncTask =
new
AsyncTask<Void, Void, Integer>() {
@Override
protected
Integer doInBackground(Void... params) {
int
i =
0
;
//模擬耗時操作
while
(!isCancelled()) {
i++;
if
(i >
1000000000
) {
break
;
}
Log.e(
"LeakCanary"
,
"asyncTask---->"
+ i);
}
return
i;
}
@Override
protected
void
onPostExecute(Integer integer) {
super
.onPostExecute(integer);
mTextView.setText(String.valueOf(integer));
}
};
asyncTask.execute();
}
private
void
destroyAsyncTask() {
if
(asyncTask !=
null
&& !asyncTask.isCancelled()) {
asyncTask.cancel(
true
);
}
asyncTask =
null
;
}
@Override
protected
void
onDestroy() {
super
.onDestroy();
destroyAsyncTask();
LApplication.getRefWatcher().watch(
this
);
}
}
|
4.）非靜態內部類創建靜態實例造成的內存泄漏
有時我們需要一個可以隨着屏幕旋轉的Activity，比如視頻播放Activity，這時我們為了防止多次調用onCreate方法導致某些參數重新初始化，我們一般會選擇創建一個內部類和一個靜態實例來保存這些參數，比如以下實現：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
public
class
MainActivity
extends
AppCompatActivity {
private
static
Config mConfig;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//模擬內存泄露
if
(mConfig ==
null
) {
mConfig =
new
Config();
mConfig.setSize(
18
);
mConfig.setTitle(
"老九門"
);
}
finish();
}
@Override
protected
void
onDestroy() {
super
.onDestroy();
LApplication.getRefWatcher().watch(
this
);
}
class
Config {
private
int
size;
private
String title;
public
int
getSize() {
return
size;
}
public
void
setSize(
int
size) {
this
.size = size;
}
public
String getTitle() {
return
title;
}
public
void
setTitle(String title) {
this
.title = title;
}
}
}
|
上述代碼看着沒有任何問題，其實內部類都會持有一個外部類引用，這里這個外部類就是MainActivity，然而內部類實例又是static靜態變量其生命周期與Application生命周期一樣，所以在MainActivity關閉的時候，內部類靜態實例依然持有對MainActivity的引用，導致MainActivity無法被回收釋放，引發內存泄漏。LeakCanary檢測內存泄漏結果如下：
對於這種泄漏的解決辦法就是將內部類改成靜態內部類，不再持有對MainActivity的引用即可，修改后的代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
public
class
MainActivity
extends
AppCompatActivity {
private
static
Config mConfig;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//模擬內存泄露
if
(mConfig ==
null
) {
mConfig =
new
Config();
mConfig.setSize(
18
);
mConfig.setTitle(
"老九門"
);
}
finish();
}
@Override
protected
void
onDestroy() {
super
.onDestroy();
LApplication.getRefWatcher().watch(
this
);
}
static
class
Config {
private
int
size;
private
String title;
public
int
getSize() {
return
size;
}
public
void
setSize(
int
size) {
this
.size = size;
}
public
String getTitle() {
return
title;
}
public
void
setTitle(String title) {
this
.title = title;
}
}
}
|
5.）由WebView引起的內存泄漏
在目前的開發中多多少少會用到Hybrid開發方式，這樣我們就會用WebView去承載Html網頁，就如下面這種方式：
java代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
class
MainActivity5
extends
AppCompatActivity {
private
WebView mWebView;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_web);
mWebView = (WebView) findViewById(R.id.web);
}
@Override
protected
void
onDestroy() {
super
.onDestroy();
LApplication.getRefWatcher().watch(
this
);
}
}
|
xml布局文件：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<
LinearLayout
android:id
=
"@+id/activity_main"
android:layout_width
=
"match_parent"
android:layout_height
=
"match_parent"
android:orientation
=
"vertical"
>
<
WebView
android:id
=
"@+id/web"
android:layout_width
=
"wrap_content"
android:layout_height
=
"wrap_content"
/>
</
LinearLayout
>
|
WebView解析網頁時會申請Native堆內存用於保存頁面元素，當頁面較復雜時會有很大的內存占用。如果頁面包含圖片，內存占用會更嚴重。並且打開新頁面時，為了能快速回退，之前頁面占用的內存也不會釋放。有時瀏覽十幾個網頁，都會占用幾百兆的內存。這樣加載網頁較多時，會導致系統不堪重負，最終強制關閉應用，也就是出現應用閃退或重啟。及時Activity關閉時在onDestroy中調用如下代碼也是沒有任何作用。
|
1
2
3
4
5
6
7
8
9
|
private
void
destroyWebView() {
if
(mWebView !=
null
) {
mLinearLayout.removeView(mWebView);
mWebView.pauseTimers();
mWebView.removeAllViews();
mWebView.destroy();
mWebView =
null
;
}
}
|
先看下LeakCanary檢測到的結果如下：
該如何解決呢？這個查了不少資料，其中一種就是使用getApplicationgContext作為參數構建WebView，然后動態添加到一個ViewGroup中，最后退出的時候調用webView的銷毀的函數，雖然也達到了防止內存溢出的效果，但是在有些網頁彈出時候需要記住密碼的對話框的時候，會出現Unable to add window -- token null is not for an application 的錯誤，所以這里采用的解決辦法是通過把使用了WebView的Activity(或者Service)放在單獨的進程里。然后在檢測到應用占用內存過大有可能被系統干掉或者它所在的Activity(或者Service)結束后，調用android.os.Process.killProcess(android.os.Process.myPid());，主動Kill掉進程。由於系統的內存分配是以進程為准的，進程關閉后，系統會自動回收所有內存。
修改后的代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
public
class
MainActivity5
extends
AppCompatActivity {
private
WebView mWebView;
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super
.onCreate(savedInstanceState);
setContentView(R.layout.activity_web);
mWebView = (WebView) findViewById(R.id.web);
}
@Override
protected
void
onDestroy() {
destroyWebView();
android.os.Process.killProcess(android.os.Process.myPid());
super
.onDestroy();
LApplication.getRefWatcher().watch(
this
);
}
private
void
destroyWebView() {
if
(mWebView !=
null
) {
mWebView.pauseTimers();
mWebView.removeAllViews();
mWebView.destroy();
mWebView =
null
;
}
}
}
|
manifest中對應的activity配置如下：
|
1
2
3
|
<
activity
android:name
=
".MainActivity5"
android:process
=
"com.whoislcj.webview"
/>
|
6.）資源未關閉造成的內存泄漏
對於使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等資源的使用，應該在Activity銷毀時及時關閉或者注銷，否則這些資源將不會被回收，造成內存泄漏。例如獲取媒體庫圖片地址代碼在查詢結束的時候一定要調用
Cursor 的關閉方法防止造成內存泄漏。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
String columns[] =
new
String[]{
MediaStore.Images.Media.DATA, MediaStore.Images.Media._ID, MediaStore.Images.Media.TITLE, MediaStore.Images.Media.DISPLAY_NAME
};
Cursor cursor =
this
.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, columns,
null
,
null
,
null
);
if
(cursor !=
null
) {
int
photoIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
//顯示每張圖片的地址，但是首先要判斷一下，Cursor是否有值
while
(cursor.moveToNext()) {
String photoPath = cursor.getString(photoIndex);
//這里獲取到的就是圖片存儲的位置信息
Log.e(
"LeakCanary"
,
"photoPath---->"
+ photoPath);
}
cursor.close();
}
|
總結