Android內存泄漏

時間 2019-11-13

原文原文鏈接

韓夢飛沙韓亞飛 313134555@qq.com yue31313 han_meng_fei_shajava

#Android 內存泄漏總結android

內存管理的目的就是讓咱們在開發中怎麼有效的避免咱們的應用出現內存泄漏的問題。內存泄漏你們都不陌生了，簡單粗俗的講，就是該被釋放的對象沒有釋放，一直被某個或某些實例所持有卻再也不被使用致使 GC 不能回收。最近本身閱讀了大量相關的文檔資料，打算作個總結沉澱下來跟你們一塊兒分享和學習，也給本身一個警示，之後 coding 時怎麼避免這些狀況，提升應用的體驗和質量。git

我會從 java 內存泄漏的基礎知識開始，並經過具體例子來講明 Android 引發內存泄漏的各類緣由，以及如何利用工具來分析應用內存泄漏，最後再作總結。程序員

##Java 內存分配策略github

Java 程序運行時的內存分配策略有三種,分別是靜態分配,棧式分配,和堆式分配，對應的，三種存儲策略使用的內存空間主要分別是靜態存儲區（也稱方法區）、棧區和堆區。算法

靜態存儲區（方法區）：主要存放靜態數據、全局 static 數據和常量。這塊內存在程序編譯時就已經分配好，而且在程序整個運行期間都存在。數據庫
棧區：當方法被執行時，方法體內的局部變量（其中包括基礎數據類型、對象的引用）都在棧上建立，並在方法執行結束時這些局部變量所持有的內存將會自動被釋放。由於棧內存分配運算內置於處理器的指令集中，效率很高，可是分配的內存容量有限。編程
堆區：又稱動態內存分配，一般就是指在程序運行時直接 new 出來的內存，也就是對象的實例。這部份內存在不使用時將會由 Java 垃圾回收器來負責回收。api

##棧與堆的區別：數組

在方法體內定義的（局部變量）一些基本類型的變量和對象的引用變量都是在方法的棧內存中分配的。當在一段方法塊中定義一個變量時，Java 就會在棧中爲該變量分配內存空間，當超過該變量的做用域後，該變量也就無效了，分配給它的內存空間也將被釋放掉，該內存空間能夠被從新使用。

堆內存用來存放全部由 new 建立的對象（包括該對象其中的全部成員變量）和數組。在堆中分配的內存，將由 Java 垃圾回收器來自動管理。在堆中產生了一個數組或者對象後，還能夠在棧中定義一個特殊的變量，這個變量的取值等於數組或者對象在堆內存中的首地址，這個特殊的變量就是咱們上面說的引用變量。咱們能夠經過這個引用變量來訪問堆中的對象或者數組。

舉個例子:

public class Sample {
    int s1 = 0;
    Sample mSample1 = new Sample();

    public void method() {
        int s2 = 1;
        Sample mSample2 = new Sample();
    }
}

Sample mSample3 = new Sample();

Sample 類的局部變量 s2 和引用變量 mSample2 都是存在於棧中，但 mSample2 指向的對象是存在於堆上的。 mSample3 指向的對象實體存放在堆上，包括這個對象的全部成員變量 s1 和 mSample1，而它本身存在於棧中。

結論：

局部變量的基本數據類型和引用存儲於棧中，引用的對象實體存儲於堆中。—— 由於它們屬於方法中的變量，生命週期隨方法而結束。

成員變量所有存儲與堆中（包括基本數據類型，引用和引用的對象實體）—— 由於它們屬於類，類對象終究是要被new出來使用的。

瞭解了 Java 的內存分配以後，咱們再來看看 Java 是怎麼管理內存的。

##Java是如何管理內存

Java的內存管理就是對象的分配和釋放問題。在 Java 中，程序員須要經過關鍵字 new 爲每一個對象申請內存空間 (基本類型除外)，全部的對象都在堆 (Heap)中分配空間。另外，對象的釋放是由 GC 決定和執行的。在 Java 中，內存的分配是由程序完成的，而內存的釋放是由 GC 完成的，這種收支兩條線的方法確實簡化了程序員的工做。但同時，它也加劇了JVM的工做。這也是 Java 程序運行速度較慢的緣由之一。由於，GC 爲了可以正確釋放對象，GC 必須監控每個對象的運行狀態，包括對象的申請、引用、被引用、賦值等，GC 都須要進行監控。

監視對象狀態是爲了更加準確地、及時地釋放對象，而釋放對象的根本原則就是該對象再也不被引用。

爲了更好理解 GC 的工做原理，咱們能夠將對象考慮爲有向圖的頂點，將引用關係考慮爲圖的有向邊，有向邊從引用者指向被引對象。另外，每一個線程對象能夠做爲一個圖的起始頂點，例如大多程序從 main 進程開始執行，那麼該圖就是以 main 進程頂點開始的一棵根樹。在這個有向圖中，根頂點可達的對象都是有效對象，GC將不回收這些對象。若是某個對象 (連通子圖)與這個根頂點不可達(注意，該圖爲有向圖)，那麼咱們認爲這個(這些)對象再也不被引用，能夠被 GC 回收。如下，咱們舉一個例子說明如何用有向圖表示內存管理。對於程序的每個時刻，咱們都有一個有向圖表示JVM的內存分配狀況。如下右圖，就是左邊程序運行到第6行的示意圖。

Java使用有向圖的方式進行內存管理，能夠消除引用循環的問題，例若有三個對象，相互引用，只要它們和根進程不可達的，那麼GC也是能夠回收它們的。這種方式的優勢是管理內存的精度很高，可是效率較低。另一種經常使用的內存管理技術是使用計數器，例如COM模型採用計數器方式管理構件，它與有向圖相比，精度行低(很難處理循環引用的問題)，但執行效率很高。

##什麼是Java中的內存泄露

在Java中，內存泄漏就是存在一些被分配的對象，這些對象有下面兩個特色，首先，這些對象是可達的，即在有向圖中，存在通路能夠與其相連；其次，這些對象是無用的，即程序之後不會再使用這些對象。若是對象知足這兩個條件，這些對象就能夠斷定爲Java中的內存泄漏，這些對象不會被GC所回收，然而它卻佔用內存。

在C++中，內存泄漏的範圍更大一些。有些對象被分配了內存空間，而後卻不可達，因爲C++中沒有GC，這些內存將永遠收不回來。在Java中，這些不可達的對象都由GC負責回收，所以程序員不須要考慮這部分的內存泄露。

經過分析，咱們得知，對於C++，程序員須要本身管理邊和頂點，而對於Java程序員只須要管理邊就能夠了(不須要管理頂點的釋放)。經過這種方式，Java提升了編程的效率。

所以，經過以上分析，咱們知道在Java中也有內存泄漏，但範圍比C++要小一些。由於Java從語言上保證，任何對象都是可達的，全部的不可達對象都由GC管理。

對於程序員來講，GC基本是透明的，不可見的。雖然，咱們只有幾個函數能夠訪問GC，例如運行GC的函數System.gc()，可是根據Java語言規範定義，該函數不保證JVM的垃圾收集器必定會執行。由於，不一樣的JVM實現者可能使用不一樣的算法管理GC。一般，GC的線程的優先級別較低。JVM調用GC的策略也有不少種，有的是內存使用到達必定程度時，GC纔開始工做，也有定時執行的，有的是平緩執行GC，有的是中斷式執行GC。但一般來講，咱們不須要關心這些。除非在一些特定的場合，GC的執行影響應用程序的性能，例如對於基於Web的實時系統，如網絡遊戲等，用戶不但願GC忽然中斷應用程序執行而進行垃圾回收，那麼咱們須要調整GC的參數，讓GC可以經過平緩的方式釋放內存，例如將垃圾回收分解爲一系列的小步驟執行，Sun提供的HotSpot JVM就支持這一特性。

一樣給出一個 Java 內存泄漏的典型例子，

Vector v = new Vector(10);
for (int i = 1; i < 100; i++) {
    Object o = new Object();
    v.add(o);
    o = null;   
}

在這個例子中，咱們循環申請Object對象，並將所申請的對象放入一個 Vector 中，若是咱們僅僅釋放引用自己，那麼 Vector 仍然引用該對象，因此這個對象對 GC 來講是不可回收的。所以，若是對象加入到Vector 後，還必須從 Vector 中刪除，最簡單的方法就是將 Vector 對象設置爲 null。

詳細Java中的內存泄漏

1.Java內存回收機制

不論哪一種語言的內存分配方式，都須要返回所分配內存的真實地址，也就是返回一個指針到內存塊的首地址。Java中對象是採用new或者反射的方法建立的，這些對象的建立都是在堆（Heap）中分配的，全部對象的回收都是由Java虛擬機經過垃圾回收機制完成的。GC爲了可以正確釋放對象，會監控每一個對象的運行情況，對他們的申請、引用、被引用、賦值等情況進行監控，Java會使用有向圖的方法進行管理內存，實時監控對象是否能夠達到，若是不可到達，則就將其回收，這樣也能夠消除引用循環的問題。在Java語言中，判斷一個內存空間是否符合垃圾收集標準有兩個：一個是給對象賦予了空值null，如下再沒有調用過，另外一個是給對象賦予了新值，這樣從新分配了內存空間。

2.Java內存泄漏引發的緣由

內存泄漏是指無用對象（再也不使用的對象）持續佔有內存或無用對象的內存得不到及時釋放，從而形成內存空間的浪費稱爲內存泄漏。內存泄露有時不嚴重且不易察覺，這樣開發者就不知道存在內存泄露，但有時也會很嚴重，會提示你Out of memory。j

Java內存泄漏的根本緣由是什麼呢？長生命週期的對象持有短生命週期對象的引用就極可能發生內存泄漏，儘管短生命週期對象已經再也不須要，可是由於長生命週期持有它的引用而致使不能被回收，這就是Java中內存泄漏的發生場景。具體主要有以下幾大類：

一、靜態集合類引發內存泄漏：

像HashMap、Vector等的使用最容易出現內存泄露，這些靜態變量的生命週期和應用程序一致，他們所引用的全部的對象Object也不能被釋放，由於他們也將一直被Vector等引用着。

例如

Static Vector v = new Vector(10);
for (int i = 1; i<100; i++)
{
Object o = new Object();
v.add(o);
o = null;
}

在這個例子中，循環申請Object 對象，並將所申請的對象放入一個Vector 中，若是僅僅釋放引用自己（o=null），那麼Vector 仍然引用該對象，因此這個對象對GC 來講是不可回收的。所以，若是對象加入到Vector 後，還必須從Vector 中刪除，最簡單的方法就是將Vector對象設置爲null。

二、當集合裏面的對象屬性被修改後，再調用remove()方法時不起做用。

例如：

public static void main(String[] args)
{
Set<Person> set = new HashSet<Person>();
Person p1 = new Person("唐僧","pwd1",25);
Person p2 = new Person("孫悟空","pwd2",26);
Person p3 = new Person("豬八戒","pwd3",27);
set.add(p1);
set.add(p2);
set.add(p3);
System.out.println("總共有:"+set.size()+" 個元素!"); //結果：總共有:3 個元素!
p3.setAge(2); //修改p3的年齡,此時p3元素對應的hashcode值發生改變

set.remove(p3); //此時remove不掉，形成內存泄漏

set.add(p3); //從新添加，竟然添加成功
System.out.println("總共有:"+set.size()+" 個元素!"); //結果：總共有:4 個元素!
for (Person person : set)
{
System.out.println(person);
}
}

三、監聽器

在java 編程中，咱們都須要和監聽器打交道，一般一個應用當中會用到不少監聽器，咱們會調用一個控件的諸如addXXXListener()等方法來增長監聽器，但每每在釋放對象的時候卻沒有記住去刪除這些監聽器，從而增長了內存泄漏的機會。

四、各類鏈接

好比數據庫鏈接（dataSourse.getConnection()），網絡鏈接(socket)和io鏈接，除非其顯式的調用了其close（）方法將其鏈接關閉，不然是不會自動被GC 回收的。對於Resultset 和Statement 對象能夠不進行顯式回收，但Connection 必定要顯式回收，由於Connection 在任什麼時候候都沒法自動回收，而Connection一旦回收，Resultset 和Statement 對象就會當即爲NULL。可是若是使用鏈接池，狀況就不同了，除了要顯式地關閉鏈接，還必須顯式地關閉Resultset Statement 對象（關閉其中一個，另一個也會關閉），不然就會形成大量的Statement 對象沒法釋放，從而引發內存泄漏。這種狀況下通常都會在try裏面去的鏈接，在finally裏面釋放鏈接。

五、內部類和外部模塊的引用

內部類的引用是比較容易遺忘的一種，並且一旦沒釋放可能致使一系列的後繼類對象沒有釋放。此外程序員還要當心外部模塊不經意的引用，例如程序員A 負責A 模塊，調用了B 模塊的一個方法如： public void registerMsg(Object b); 這種調用就要很是當心了，傳入了一個對象，極可能模塊B就保持了對該對象的引用，這時候就須要注意模塊B 是否提供相應的操做去除引用。

六、單例模式

不正確使用單例模式是引發內存泄漏的一個常見問題，單例對象在初始化後將在JVM的整個生命週期中存在（以靜態變量的方式），若是單例對象持有外部的引用，那麼這個對象將不能被JVM正常回收，致使內存泄漏，考慮下面的例子：

class A{
public A(){
B.getInstance().setA(this);
}
....
}
//B類採用單例模式
class B{
private A a;
private static B instance=new B();
public B(){}
public static B getInstance(){
return instance;
}
public void setA(A a){
this.a=a;
}
//getter...
}

顯然B採用singleton模式，它持有一個A對象的引用，而這個A類的對象將不能被回收。想象下若是A是個比較複雜的對象或者集合類型會發生什麼狀況

##Android中常見的內存泄漏彙總

###集合類泄漏

集合類若是僅僅有添加元素的方法，而沒有相應的刪除機制，致使內存被佔用。若是這個集合類是全局性的變量 (好比類中的靜態屬性，全局性的 map 等即有靜態引用或 final 一直指向它)，那麼沒有相應的刪除機制，極可能致使集合所佔用的內存只增不減。好比上面的典型例子就是其中一種狀況，固然實際上咱們在項目中確定不會寫這麼 2B 的代碼，但稍不注意仍是很容易出現這種狀況，好比咱們都喜歡經過 HashMap 作一些緩存之類的事，這種狀況就要多留一些心眼。

###單例形成的內存泄漏

因爲單例的靜態特性使得其生命週期跟應用的生命週期同樣長，因此若是使用不恰當的話，很容易形成內存泄漏。好比下面一個典型的例子，

public class AppManager {
private static AppManager instance;
private Context context;
private AppManager(Context context) {
this.context = context;
}
public static AppManager getInstance(Context context) {
if (instance == null) {
instance = new AppManager(context);
}
return instance;
}
}

這是一個普通的單例模式，當建立這個單例的時候，因爲須要傳入一個Context，因此這個Context的生命週期的長短相當重要：

一、若是此時傳入的是 Application 的 Context，由於 Application 的生命週期就是整個應用的生命週期，因此這將沒有任何問題。

二、若是此時傳入的是 Activity 的 Context，當這個 Context 所對應的 Activity 退出時，因爲該 Context 的引用被單例對象所持有，其生命週期等於整個應用程序的生命週期，因此當前 Activity 退出時它的內存並不會被回收，這就形成泄漏了。

正確的方式應該改成下面這種方式：

public class AppManager {
private static AppManager instance;
private Context context;
private AppManager(Context context) {
this.context = context.getApplicationContext();// 使用Application 的context
}
public static AppManager getInstance(Context context) {
if (instance == null) {
instance = new AppManager(context);
}
return instance;
}
}

或者這樣寫，連 Context 都不用傳進來了：

在你的 Application 中添加一個靜態方法，getContext() 返回 Application 的 context，

...

context = getApplicationContext();

...
   /**
     * 獲取全局的context
     * @return 返回全局context對象
     */
    public static Context getContext(){
        return context;
    }

public class AppManager {
private static AppManager instance;
private Context context;
private AppManager() {
this.context = MyApplication.getContext();// 使用Application 的context
}
public static AppManager getInstance() {
if (instance == null) {
instance = new AppManager();
}
return instance;
}
}

###匿名內部類/非靜態內部類和異步線程

非靜態內部類建立靜態實例形成的內存泄漏

有的時候咱們可能會在啓動頻繁的Activity中，爲了不重複建立相同的數據資源，可能會出現這種寫法：

public class MainActivity extends AppCompatActivity {
        private static TestResource mResource = null;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        if(mManager == null){
        mManager = new TestResource();
        }
        //...
        }
        class TestResource {
        //...
        }
        }

這樣就在Activity內部建立了一個非靜態內部類的單例，每次啓動Activity時都會使用該單例的數據，這樣雖然避免了資源的重複建立，不過這種寫法卻會形成內存泄漏，由於非靜態內部類默認會持有外部類的引用，而該非靜態內部類又建立了一個靜態的實例，該實例的生命週期和應用的同樣長，這就致使了該靜態實例一直會持有該Activity的引用，致使Activity的內存資源不能正常回收。正確的作法爲：

將該內部類設爲靜態內部類或將該內部類抽取出來封裝成一個單例，若是須要使用Context，請按照上面推薦的使用Application 的 Context。固然，Application 的 context 不是萬能的，因此也不能隨便亂用，對於有些地方則必須使用 Activity 的 Context，對於Application，Service，Activity三者的Context的應用場景以下：

其中： NO1表示 Application 和 Service 能夠啓動一個 Activity，不過須要建立一個新的 task 任務隊列。而對於 Dialog 而言，只有在 Activity 中才能建立

###匿名內部類

android開發常常會繼承實現Activity/Fragment/View，此時若是你使用了匿名類，並被異步線程持有了，那要當心了，若是沒有任何措施這樣必定會致使泄露

public class MainActivity extends Activity {
    ...
    Runnable ref1 = new MyRunable();
    Runnable ref2 = new Runnable() {
        @Override
        public void run() {

        }
    };
       ...
    }

ref1和ref2的區別是，ref2使用了匿名內部類。咱們來看看運行時這兩個引用的內存：

能夠看到，ref1沒什麼特別的。

但ref2這個匿名類的實現對象裏面多了一個引用：

this$0這個引用指向MainActivity.this，也就是說當前的MainActivity實例會被ref2持有，若是將這個引用再傳入一個異步線程，此線程和此Acitivity生命週期不一致的時候，就形成了Activity的泄露。

###Handler 形成的內存泄漏

Handler 的使用形成的內存泄漏問題應該說是最爲常見了，不少時候咱們爲了不 ANR 而不在主線程進行耗時操做，在處理網絡任務或者封裝一些請求回調等api都藉助Handler來處理，但 Handler 不是萬能的，對於 Handler 的使用代碼編寫一不規範即有可能形成內存泄漏。另外，咱們知道 Handler、Message 和 MessageQueue 都是相互關聯在一塊兒的，萬一 Handler 發送的 Message 還沒有被處理，則該 Message 及發送它的 Handler 對象將被線程 MessageQueue 一直持有。

因爲 Handler 屬於 TLS(Thread Local Storage) 變量, 生命週期和 Activity 是不一致的。所以這種實現方式通常很難保證跟 View 或者 Activity 的生命週期保持一致，故很容易致使沒法正確釋放。

舉個例子：

public class SampleActivity extends Activity {

    private final Handler mLeakyHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      // ...
    }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for 10 minutes.
    mLeakyHandler.postDelayed(new Runnable() {
      @Override
      public void run() { /* ... */ }
    }, 1000 * 60 * 10);

    // Go back to the previous Activity.
    finish();
    }
    }

在該 SampleActivity 中聲明瞭一個延遲10分鐘執行的消息 Message，mLeakyHandler 將其 push 進了消息隊列 MessageQueue 裏。當該 Activity 被 finish() 掉時，延遲執行任務的 Message 還會繼續存在於主線程中，它持有該 Activity 的 Handler 引用，因此此時 finish() 掉的 Activity 就不會被回收了從而形成內存泄漏（因 Handler 爲非靜態內部類，它會持有外部類的引用，在這裏就是指 SampleActivity）。

修復方法：在 Activity 中避免使用非靜態內部類，好比上面咱們將 Handler 聲明爲靜態的，則其存活期跟 Activity 的生命週期就無關了。同時經過弱引用的方式引入 Activity，避免直接將 Activity 做爲 context 傳進去，見下面代碼：

public class SampleActivity extends Activity {

  /**
   * Instances of static inner classes do not hold an implicit
   * reference to their outer class.
   */
  private static class MyHandler extends Handler {
    private final WeakReference<SampleActivity> mActivity;

    public MyHandler(SampleActivity activity) {
      mActivity = new WeakReference<SampleActivity>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
      SampleActivity activity = mActivity.get();
      if (activity != null) {
        // ...
      }
    }
  }

  private final MyHandler mHandler = new MyHandler(this);

  /**
   * Instances of anonymous classes do not hold an implicit
   * reference to their outer class when they are "static".
   */
  private static final Runnable sRunnable = new Runnable() {
      @Override
      public void run() { /* ... */ }
  };

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for 10 minutes.
    mHandler.postDelayed(sRunnable, 1000 * 60 * 10);

    // Go back to the previous Activity.
    finish();
  }
}

綜述，即推薦使用靜態內部類 + WeakReference 這種方式。每次使用前注意判空。

前面提到了 WeakReference，因此這裏就簡單的說一下 Java 對象的幾種引用類型。

Java對引用的分類有 Strong reference, SoftReference, WeakReference, PhatomReference 四種。

在Android應用的開發中，爲了防止內存溢出，在處理一些佔用內存大並且聲明週期較長的對象時候，能夠儘可能應用軟引用和弱引用技術。

軟/弱引用能夠和一個引用隊列（ReferenceQueue）聯合使用，若是軟引用所引用的對象被垃圾回收器回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。利用這個隊列能夠得知被回收的軟/弱引用的對象列表，從而爲緩衝器清除已失效的軟/弱引用。

假設咱們的應用會用到大量的默認圖片，好比應用中有默認的頭像，默認遊戲圖標等等，這些圖片不少地方會用到。若是每次都去讀取圖片，因爲讀取文件須要硬件操做，速度較慢，會致使性能較低。因此咱們考慮將圖片緩存起來，須要的時候直接從內存中讀取。可是，因爲圖片佔用內存空間比較大，緩存不少圖片須要不少的內存，就可能比較容易發生OutOfMemory異常。這時，咱們能夠考慮使用軟/弱引用技術來避免這個問題發生。如下就是高速緩衝器的雛形：

首先定義一個HashMap，保存軟引用對象。

private Map <String, SoftReference<Bitmap>> imageCache = new HashMap <String, SoftReference<Bitmap>> ();

再來定義一個方法，保存Bitmap的軟引用到HashMap。

使用軟引用之後，在OutOfMemory異常發生以前，這些緩存的圖片資源的內存空間能夠被釋放掉的，從而避免內存達到上限，避免Crash發生。

若是隻是想避免OutOfMemory異常的發生，則可使用軟引用。若是對於應用的性能更在乎，想盡快回收一些佔用內存比較大的對象，則可使用弱引用。

另外能夠根據對象是否常用來判斷選擇軟引用仍是弱引用。若是該對象可能會常用的，就儘可能用軟引用。若是該對象不被使用的可能性更大些，就能夠用弱引用。

ok，繼續回到主題。前面所說的，建立一個靜態Handler內部類，而後對 Handler 持有的對象使用弱引用，這樣在回收時也能夠回收 Handler 持有的對象，可是這樣作雖然避免了 Activity 泄漏，不過 Looper 線程的消息隊列中仍是可能會有待處理的消息，因此咱們在 Activity 的 Destroy 時或者 Stop 時應該移除消息隊列 MessageQueue 中的消息。

下面幾個方法均可以移除 Message：

public final void removeCallbacks(Runnable r);

public final void removeCallbacks(Runnable r, Object token);

public final void removeCallbacksAndMessages(Object token);

public final void removeMessages(int what);

public final void removeMessages(int what, Object object);

###儘可能避免使用 static 成員變量

若是成員變量被聲明爲 static，那咱們都知道其生命週期將與整個app進程生命週期同樣。

這會致使一系列問題，若是你的app進程設計上是長駐內存的，那即便app切到後臺，這部份內存也不會被釋放。按照如今手機app內存管理機制，佔內存較大的後臺進程將優先回收，yi'wei若是此app作過進程互保保活，那會形成app在後臺頻繁重啓。當手機安裝了你參與開發的app之後一晚上時間手機被消耗空了電量、流量，你的app不得不被用戶卸載或者靜默。

這裏修復的方法是：

不要在類初始時初始化靜態成員。能夠考慮lazy初始化。架構設計上要思考是否真的有必要這樣作，儘可能避免。若是架構須要這麼設計，那麼此對象的生命週期你有責任管理起來。

###避免 override finalize()

一、finalize 方法被執行的時間不肯定，不能依賴與它來釋放緊缺的資源。時間不肯定的緣由是：虛擬機調用GC的時間不肯定 Finalize daemon線程被調度到的時間不肯定

二、finalize 方法只會被執行一次，即便對象被複活，若是已經執行過了 finalize 方法，再次被 GC 時也不會再執行了，緣由是：

含有 finalize 方法的 object 是在 new 的時候由虛擬機生成了一個 finalize reference 在來引用到該Object的，而在 finalize 方法執行的時候，該 object 所對應的 finalize Reference 會被釋放掉，即便在這個時候把該 object 復活(即用強引用引用住該 object )，再第二次被 GC 的時候因爲沒有了 finalize reference 與之對應，因此 finalize 方法不會再執行。

三、含有Finalize方法的object須要至少通過兩輪GC纔有可能被釋放。

###資源未關閉形成的內存泄漏

對於使用了BraodcastReceiver，ContentObserver，File，遊標 Cursor，Stream，Bitmap等資源的使用，應該在Activity銷燬時及時關閉或者註銷，不然這些資源將不會被回收，形成內存泄漏。

###一些不良代碼形成的內存壓力

有些代碼並不形成內存泄露，可是它們，或是對沒使用的內存沒進行有效及時的釋放，或是沒有有效的利用已有的對象而是頻繁的申請新內存。

好比： Bitmap 沒調用 recycle()方法，對於 Bitmap 對象在不使用時,咱們應該先調用 recycle() 釋放內存，而後才它設置爲 null. 由於加載 Bitmap 對象的內存空間，一部分是 java 的，一部分 C 的（由於 Bitmap 分配的底層是經過 JNI 調用的 )。而這個 recyle() 就是針對 C 部分的內存釋放。構造 Adapter 時，沒有使用緩存的 convertView ,每次都在建立新的 converView。這裏推薦使用 ViewHolder。

##總結

對 Activity 等組件的引用應該控制在 Activity 的生命週期以內；若是不能就考慮使用 getApplicationContext 或者 getApplication，以免 Activity 被外部長生命週期的對象引用而泄露。

儘可能不要在靜態變量或者靜態內部類中使用非靜態外部成員變量（包括context )，即便要使用，也要考慮適時把外部成員變量置空；也能夠在內部類中使用弱引用來引用外部類的變量。

對於生命週期比Activity長的內部類對象，而且內部類中使用了外部類的成員變量，能夠這樣作避免內存泄漏：

將內部類改成靜態內部類
    靜態內部類中使用弱引用來引用外部類的成員變量

Handler 的持有的引用對象最好使用弱引用，資源釋放時也能夠清空 Handler 裏面的消息。好比在 Activity onStop 或者 onDestroy 的時候，取消掉該 Handler 對象的 Message和 Runnable.

在 Java 的實現過程當中，也要考慮其對象釋放，最好的方法是在不使用某對象時，顯式地將此對象賦值爲 null，好比使用完Bitmap 後先調用 recycle()，再賦爲null,清空對圖片等資源有直接引用或者間接引用的數組（使用 array.clear() ; array = null）等，最好遵循誰建立誰釋放的原則。

正確關閉資源，對於使用了BraodcastReceiver，ContentObserver，File，遊標 Cursor，Stream，Bitmap等資源的使用，應該在Activity銷燬時及時關閉或者註銷。

保持對對象生命週期的敏感，特別注意單例、靜態對象、全局性集合等的生命週期。

=======

#Handler內存泄漏分析及解決

###1、介紹

首先，請瀏覽下面這段handler代碼：

public class SampleActivity extends Activity {
  private final Handler mLeakyHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      // ... 
    }
  }
}

在使用handler時，這是一段很常見的代碼。可是，它卻會形成嚴重的內存泄漏問題。在實際編寫中，咱們每每會獲得以下警告：

⚠ In Android, Handler classes should be static or leaks might occur.

###2、分析

一、 Android角度

當Android應用程序啓動時，framework會爲該應用程序的主線程建立一個Looper對象。這個Looper對象包含一個簡單的消息隊列Message Queue，而且可以循環的處理隊列中的消息。這些消息包括大多數應用程序framework事件，例如Activity生命週期方法調用、button點擊等，這些消息都會被添加到消息隊列中並被逐個處理。

另外，主線程的Looper對象會伴隨該應用程序的整個生命週期。

而後，當主線程裏，實例化一個Handler對象後，它就會自動與主線程Looper的消息隊列關聯起來。全部發送到消息隊列的消息Message都會擁有一個對Handler的引用，因此當Looper來處理消息時，會據此回調[Handler#handleMessage(Message)]方法來處理消息。

二、 Java角度

在java裏，非靜態內部類和匿名類都會潛在的引用它們所屬的外部類。可是，靜態內部類卻不會。

###3、泄漏來源

請瀏覽下面一段代碼：

public class SampleActivity extends Activity {

  private final Handler mLeakyHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      // ...
    }
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for 10 minutes.
    mLeakyHandler.postDelayed(new Runnable() {
      @Override
      public void run() { /* ... */ }
    }, 1000 * 60 * 10);

    // Go back to the previous Activity.
    finish();
  }
}

當activity結束(finish)時，裏面的延時消息在獲得處理前，會一直保存在主線程的消息隊列裏持續10分鐘。並且，由上文可知，這條消息持有對handler的引用，而handler又持有對其外部類（在這裏，即SampleActivity）的潛在引用。這條引用關係會一直保持直到消息獲得處理，從而，這阻止了SampleActivity被垃圾回收器回收，同時形成應用程序的泄漏。

<<<<<<< HEAD 注意，上面代碼中的Runnable類--非靜態匿名類--一樣持有對其外部類的引用。從而也致使泄漏。

======= 注意，上面代碼中的Runnable類--非靜態匿名類--一樣持有對其外部類的引用。從而也致使泄漏。

c67abfcfd66909095068cb5f0c8632dc5547131b ###4、泄漏解決方案

首先，上面已經明確了內存泄漏來源：

只要有未處理的消息，那麼消息會引用handler，非靜態的handler又會引用外部類，即Activity，致使Activity沒法被回收，形成泄漏；

Runnable類屬於非靜態匿名類，一樣會引用外部類。

爲了解決遇到的問題，咱們要明確一點：靜態內部類不會持有對外部類的引用。因此，咱們能夠把handler類放在單獨的類文件中，或者使用靜態內部類即可以免泄漏。

另外，若是想要在handler內部去調用所在的外部類Activity，那麼能夠在handler內部使用弱引用的方式指向所在Activity，這樣統一不會致使內存泄漏。

對於匿名類Runnable，一樣能夠將其設置爲靜態類。由於靜態的匿名類不會持有對外部類的引用。

public class SampleActivity extends Activity {

  /**
   * Instances of static inner classes do not hold an implicit
   * reference to their outer class.
   */
  private static class MyHandler extends Handler {
    private final WeakReference<SampleActivity> mActivity;

    public MyHandler(SampleActivity activity) {
      mActivity = new WeakReference<SampleActivity>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
      SampleActivity activity = mActivity.get();
      if (activity != null) {
        // ...
      }
    }
  }

  private final MyHandler mHandler = new MyHandler(this);

  /**
   * Instances of anonymous classes do not hold an implicit
   * reference to their outer class when they are "static".
   */
  private static final Runnable sRunnable = new Runnable() {
      @Override
      public void run() { /* ... */ }
  };

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for 10 minutes.
    mHandler.postDelayed(sRunnable, 1000 * 60 * 10);

    // Go back to the previous Activity.
    finish();
  }
}

###5、小結

<<<<<<< HEAD 雖然靜態類與非靜態類之間的區別並不大，可是對於Android開發者而言倒是必須理解的。至少咱們要清楚，若是一個內部類實例的生命週期比Activity更長，那麼咱們千萬不要使用非靜態的內部類。最好的作法是，使用靜態內部類，而後在該類裏使用弱引用來指向所在的Activity。

原文連接：