2. 程式人生 > >[轉]Android 如何有效的解決記憶體洩漏的問題 Android 如何有效的解決記憶體洩漏的問題

[轉]Android 如何有效的解決記憶體洩漏的問題 Android 如何有效的解決記憶體洩漏的問題

阿新 • • 發佈：2018-11-01

Android 如何有效的解決記憶體洩漏的問題

 

前言：最近在研究Handler的知識，其中涉及到一個問題，如何避免Handler帶來的記憶體溢位問題。在網上找了很多資料，有很多都是互相抄的，沒有實際的作用。

本文的記憶體洩漏檢測工具是：LeakCanary  github地址：https://github.com/square/leakcanary

 

什麼是記憶體洩漏？

  • 記憶體洩漏是當程式不再使用到的記憶體時，釋放記憶體失敗而產生了無用的記憶體消耗。記憶體洩漏並不是指物理上的記憶體消失，這裡的記憶體洩漏是值由程式分配的記憶體但是由於程式邏輯錯誤而導致程式失去了對該記憶體的控制，使得記憶體浪費。

怎樣會導致記憶體洩漏？

  • 資源物件沒關閉造成的記憶體洩漏，如查詢資料庫後沒有關閉遊標cursor
  • 構造Adapter時，沒有使用 convertView 重用
  • Bitmap物件不在使用時呼叫recycle()釋放記憶體
  • 物件被生命週期長的物件引用，如activity被靜態集合引用導致activity不能釋放

 

記憶體洩漏有什麼危害？

  • 記憶體洩漏對於app沒有直接的危害，即使app有發生記憶體洩漏的情況，也不一定會引起app崩潰，但是會增加app記憶體的佔用。記憶體得不到釋放，慢慢的會造成app記憶體溢位。所以我們解決記憶體洩漏的目的就是防止app發生記憶體溢位。

 

1、新建執行緒引起的Activity記憶體洩漏

例子：

package rxnet.zyj.com.myapplication;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

public class Activity6 extends AppCompatActivity {

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

        findViewById( R.id.finish).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //模擬耗時操作
                    Thread.sleep( 15000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }
}

　　執行上面的程式碼後，點選finish按鈕,過一會兒發生了記憶體洩漏的問題。

 為什麼Activity6會發生記憶體洩漏？

進入Activity6 介面，然後點選finish按鈕，Activity6銷燬，但是Activity6裡面的執行緒還在執行，匿名內部類Runnable物件引用了Activity6的例項，導致Activity6所佔用的記憶體不能被GC及時回收。

 

 如何改進？

Runnable改為靜態非匿名內部類即可。

package rxnet.zyj.com.myapplication;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

public class Activity6 extends AppCompatActivity {

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

        findViewById( R.id.finish).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        new Thread( new MyRunnable()).start();

    }

    private static class MyRunnable implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep( 15000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
}

　　

 2、Activity新增監聽器造成Activity記憶體洩漏

package rxnet.zyj.com.myapplication;

import android.app.Activity;
import android.os.Bundle;

public class LeakActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        NastyManager.getInstance().addListener(this);
    }
}

　　這個是在開發中經常會犯的錯誤，NastyManager.getInstance() 是一個單例，當我們通過 addListener(this) 將 Activity 作為 Listener 和 NastyManager 繫結起來的時候，不好的事情就發生了。

如何改進？

想要修復這樣的 Bug，其實相當簡單，就是在你的 Acitivity 被銷燬的時候，將他和 NastyManager 取消掉繫結就好了。

package rxnet.zyj.com.myapplication;

import android.app.Activity;
import android.os.Bundle;

public class LeakActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        NastyManager.getInstance().addListener(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        NastyManager.getInstance().removeListener(this);
    }
}

　　

3、Handler 匿名內部類造成記憶體溢位？

先看著一段程式碼

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;

    private final Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.d("mmmmmmmm" , "handler " + msg.what ) ;
        }
    };

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.sendEmptyMessage( MESSAGECODE ) ;
                try {
                    Thread.sleep( 8000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                handler.sendEmptyMessage( MESSAGECODE ) ;
            }
        }).start() ;

    }
}

　　這段程式碼執行起來後，立即點選 finish 按鈕，通過檢測，發現 HandlerActivity 出現了記憶體洩漏。當Activity finish後，延時訊息會繼續存在主執行緒訊息佇列中8秒鐘，然後處理訊息。而該訊息引用了Activity的Handler物件，然後這個Handler又引用了這個Activity。這些引用物件會保持到該訊息被處理完，這樣就導致該Activity物件無法被回收，從而導致了上面說的 Activity洩露。Handler 是個很常用也很有用的類，非同步，執行緒安全等等。如果有下面這樣的程式碼，會發生什麼呢？ handler.postDeslayed ，假設 delay 時間是幾個小時… 這意味著什麼？意味著只要 handler 的訊息還沒有被處理結束，它就一直存活著，包含它的 Activity 就跟著活著。我們來想辦法修復它，修復的方案是 WeakReference ，也就是所謂的弱引用。垃圾回收器在回收的時候，是會忽視掉弱引用的，所以包含它的 Activity 會被正常清理掉。

如何避免

  • 使用靜態內部類
  • 使用弱引用

修改後程式碼是這樣的。

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.lang.ref.WeakReference;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;
    private static Handler handler ;

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        handler = new MyHandler( this ) ;

        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.sendEmptyMessage( MESSAGECODE ) ;
                try {
                    Thread.sleep( 8000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                handler.sendEmptyMessage( MESSAGECODE ) ;
            }
        }).start() ;

    }

    private static class MyHandler extends Handler {
        WeakReference<HandlerActivity> weakReference ;

        public MyHandler(HandlerActivity activity ){
            weakReference  = new WeakReference<HandlerActivity>( activity) ;
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if ( weakReference.get() != null ){
                // update android ui
                Log.d("mmmmmmmm" , "handler " + msg.what ) ;
            }
        }
    }
}

　　這個Handler已經使用了靜態內部類，並且使用了弱引用。但是這個並沒有完全解決 HandlerActivity 記憶體洩漏的問題，罪魁禍首是執行緒建立的方式出了問題，就像本文的第一個例子一樣。改進的方式，是把Runnable類寫成靜態內部類。

最終完整的程式碼如下：

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.lang.ref.WeakReference;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;
    private static Handler handler ;

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //建立Handler
        handler = new MyHandler( this ) ;

        //建立執行緒並且啟動執行緒
        new Thread( new MyRunnable() ).start();
    }

    private static class MyHandler extends Handler {
        WeakReference<HandlerActivity> weakReference ;

        public MyHandler(HandlerActivity activity ){
            weakReference  = new WeakReference<HandlerActivity>( activity) ;
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if ( weakReference.get() != null ){
                // update android ui
                Log.d("mmmmmmmm" , "handler " + msg.what ) ;
            }
        }
    }

    private static class MyRunnable implements Runnable {

        @Override
        public void run() {
            handler.sendEmptyMessage( MESSAGECODE ) ;
            try {
                Thread.sleep( 8000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            handler.sendEmptyMessage( MESSAGECODE ) ;
        }
    }
}

　　等等，還沒完呢？

上面這個程式碼已經有效的解決了Handler，Runnable 引用Activity例項從而導致記憶體洩漏的問題，但是這不夠。因為記憶體洩漏的核心原因就是這個某個物件應該被系統回收記憶體的時候，卻被其他物件引用，造成該記憶體無法回收。所以我們在寫程式碼的時候，要始終繃著這個弦。再回到上面這個問題，噹噹前Activity呼叫finish銷燬的時候，在這個Activity裡面所有執行緒是不是應該在OnDestory()方法裡，取消執行緒。當然是否取消非同步任務，要看專案具體的需求，比如在Activity銷燬的時候，啟動一個執行緒，非同步寫log日誌到本地磁碟，針對這個需求卻需要在OnDestory()方法裡開啟執行緒。所以根據當前環境做出選擇才是正解。

所以我們還可以修改程式碼為：在onDestroy() 裡面移除所有的callback 和 Message 。

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.lang.ref.WeakReference;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;
    private static Handler handler ;

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //建立Handler
        handler = new MyHandler( this ) ;

        //建立執行緒並且啟動執行緒
        new Thread( new MyRunnable() ).start();
    }

    private static class MyHandler extends Handler {
        WeakReference<HandlerActivity> weakReference ;

        public MyHandler(HandlerActivity activity ){
            weakReference  = new WeakReference<HandlerActivity>( activity) ;
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if ( weakReference.get() != null ){
                // update android ui
                Log.d("mmmmmmmm" , "handler " + msg.what ) ;
            }
        }
    }

    private static class MyRunnable implements Runnable {

        @Override
        public void run() {
            handler.sendEmptyMessage( MESSAGECODE ) ;
            try {
                Thread.sleep( 8000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            handler.sendEmptyMessage( MESSAGECODE ) ;
        }
    }

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

       //如果引數為null的話，會將所有的Callbacks和Messages全部清除掉。
        handler.removeCallbacksAndMessages( null );
    }
}

　　

 

 

4、AsyncTask造成記憶體洩漏

package rxnet.zyj.com.myapplication;

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

public class Activity2 extends AppCompatActivity {

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

        findViewById( R.id.finish2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });


        new AsyncTask<String,Integer,String>(){

            @Override
            protected String doInBackground(String... params) {
                try {
                    Thread.sleep( 6000 );
                } catch (InterruptedException e) {
                }
                return "ssss";
            }

            @Override
            protected void onPostExecute(String s) {
                super.onPostExecute(s);
                Log.d( "mmmmmm activity2 " , "" + s ) ;
            }

        }.executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR , "" ) ;
        
    }
}

　　為什麼？

上面程式碼在activity中建立了一個匿名類AsyncTask，匿名類和非靜態內部類相同，會持有外部類物件，這裡也就是activity，因此如果你在Activity裡宣告且例項化一個匿名的AsyncTask物件，則可能會發生記憶體洩漏，如果這個執行緒在Activity銷燬後還一直在後臺執行，那這個執行緒會繼續持有這個Activity的引用從而不會被GC回收，直到執行緒執行完成。

   怎麼解決？

  •  自定義靜態AsyncTask類
  • AsyncTask的週期和Activity週期保持一致。也就是在Activity生命週期結束時要將AsyncTask cancel掉。

 

package rxnet.zyj.com.myapplication;

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

public class AsyncTaskActivity extends AppCompatActivity {

    private static MyTask myTask ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_asynctask);

        findViewById( R.id.finish).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        myTask = new MyTask() ;
        myTask.executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR , "") ;

    }

    private static class MyTask extends AsyncTask{

        @Override
        protected Object doInBackground(Object[] params) {
            try {
                //模擬耗時操作
                Thread.sleep( 15000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "";
        }
    }

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

        //取消非同步任務
        if ( myTask != null ){
            myTask.cancel(true ) ;
        }
    }
}

 

5、Timer Tasks 造成記憶體洩漏

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;

import java.util.Timer;
import java.util.TimerTask;

public class TimerActivity extends AppCompatActivity {

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

        findViewById( R.id.finish2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //開始定時任務
        timer();
    }

    void timer(){
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                while(true);
            }
        },1000 );  // 1秒後啟動一個任務
    }
}

　　

  為什麼？ 

這裡記憶體洩漏在於Timer和TimerTask沒有進行Cancel，從而導致Timer和TimerTask一直引用外部類Activity。

  怎麼解決？ 

  • 在適當的時機進行Cancel。
  • TimerTask用靜態內部類

   注意：在網上看到一些資料說，解決TimerTask記憶體洩漏可以使用在適當的時機進行Cancel。經過測試，證明單單使用在適當的時機進行Cancel ， 還是有記憶體洩漏的問題。所以一定要用靜態內部類配合使用。

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.util.Timer;
import java.util.TimerTask;

public class TimerActivity extends AppCompatActivity {

    private TimerTask timerTask ;

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

        findViewById( R.id.finish2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //開始定時任務
        timer();
    }

    void timer(){
        timerTask = new MyTimerTask() ;
        new Timer().schedule( timerTask ,1000 );  // 1秒後啟動一個任務
    }

    private static class MyTimerTask extends TimerTask{

        @Override
        public void run() {
            while(true){
                Log.d( "ttttttttt" , "timerTask" ) ;
            }
        }
    }

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

        //取消定時任務
        if ( timerTask != null ){
            timerTask.cancel() ;
        }
    }
}

 原文連結：

http://www.cnblogs.com/zhaoyanjun/p/5981386.html#

前言：最近在研究Handler的知識，其中涉及到一個問題，如何避免Handler帶來的記憶體溢位問題。在網上找了很多資料，有很多都是互相抄的，沒有實際的作用。

本文的記憶體洩漏檢測工具是：LeakCanary  github地址：https://github.com/square/leakcanary

 

什麼是記憶體洩漏？

  • 記憶體洩漏是當程式不再使用到的記憶體時，釋放記憶體失敗而產生了無用的記憶體消耗。記憶體洩漏並不是指物理上的記憶體消失，這裡的記憶體洩漏是值由程式分配的記憶體但是由於程式邏輯錯誤而導致程式失去了對該記憶體的控制，使得記憶體浪費。

怎樣會導致記憶體洩漏？

  • 資源物件沒關閉造成的記憶體洩漏，如查詢資料庫後沒有關閉遊標cursor
  • 構造Adapter時，沒有使用 convertView 重用
  • Bitmap物件不在使用時呼叫recycle()釋放記憶體
  • 物件被生命週期長的物件引用，如activity被靜態集合引用導致activity不能釋放

 

記憶體洩漏有什麼危害？

  • 記憶體洩漏對於app沒有直接的危害，即使app有發生記憶體洩漏的情況，也不一定會引起app崩潰，但是會增加app記憶體的佔用。記憶體得不到釋放，慢慢的會造成app記憶體溢位。所以我們解決記憶體洩漏的目的就是防止app發生記憶體溢位。

 

1、新建執行緒引起的Activity記憶體洩漏

例子：

package rxnet.zyj.com.myapplication;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

public class Activity6 extends AppCompatActivity {

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

        findViewById( R.id.finish).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //模擬耗時操作
                    Thread.sleep( 15000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }
}

　　執行上面的程式碼後，點選finish按鈕,過一會兒發生了記憶體洩漏的問題。

 為什麼Activity6會發生記憶體洩漏？

進入Activity6 介面，然後點選finish按鈕，Activity6銷燬，但是Activity6裡面的執行緒還在執行，匿名內部類Runnable物件引用了Activity6的例項，導致Activity6所佔用的記憶體不能被GC及時回收。

 

 如何改進？

Runnable改為靜態非匿名內部類即可。

package rxnet.zyj.com.myapplication;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

public class Activity6 extends AppCompatActivity {

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

        findViewById( R.id.finish).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        new Thread( new MyRunnable()).start();

    }

    private static class MyRunnable implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep( 15000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
}

　　

 2、Activity新增監聽器造成Activity記憶體洩漏

package rxnet.zyj.com.myapplication;

import android.app.Activity;
import android.os.Bundle;

public class LeakActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        NastyManager.getInstance().addListener(this);
    }
}

　　這個是在開發中經常會犯的錯誤，NastyManager.getInstance() 是一個單例，當我們通過 addListener(this) 將 Activity 作為 Listener 和 NastyManager 繫結起來的時候，不好的事情就發生了。

如何改進？

想要修復這樣的 Bug，其實相當簡單，就是在你的 Acitivity 被銷燬的時候，將他和 NastyManager 取消掉繫結就好了。

package rxnet.zyj.com.myapplication;

import android.app.Activity;
import android.os.Bundle;

public class LeakActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        NastyManager.getInstance().addListener(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        NastyManager.getInstance().removeListener(this);
    }
}

　　

3、Handler 匿名內部類造成記憶體溢位？

先看著一段程式碼

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;

    private final Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.d("mmmmmmmm" , "handler " + msg.what ) ;
        }
    };

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.sendEmptyMessage( MESSAGECODE ) ;
                try {
                    Thread.sleep( 8000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                handler.sendEmptyMessage( MESSAGECODE ) ;
            }
        }).start() ;

    }
}

　　這段程式碼執行起來後，立即點選 finish 按鈕，通過檢測，發現 HandlerActivity 出現了記憶體洩漏。當Activity finish後，延時訊息會繼續存在主執行緒訊息佇列中8秒鐘，然後處理訊息。而該訊息引用了Activity的Handler物件，然後這個Handler又引用了這個Activity。這些引用物件會保持到該訊息被處理完，這樣就導致該Activity物件無法被回收，從而導致了上面說的 Activity洩露。Handler 是個很常用也很有用的類，非同步，執行緒安全等等。如果有下面這樣的程式碼，會發生什麼呢？ handler.postDeslayed ，假設 delay 時間是幾個小時… 這意味著什麼？意味著只要 handler 的訊息還沒有被處理結束，它就一直存活著，包含它的 Activity 就跟著活著。我們來想辦法修復它，修復的方案是 WeakReference ，也就是所謂的弱引用。垃圾回收器在回收的時候，是會忽視掉弱引用的，所以包含它的 Activity 會被正常清理掉。

如何避免

  • 使用靜態內部類
  • 使用弱引用

修改後程式碼是這樣的。

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.lang.ref.WeakReference;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;
    private static Handler handler ;

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        handler = new MyHandler( this ) ;

        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.sendEmptyMessage( MESSAGECODE ) ;
                try {
                    Thread.sleep( 8000 );
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                handler.sendEmptyMessage( MESSAGECODE ) ;
            }
        }).start() ;

    }

    private static class MyHandler extends Handler {
        WeakReference<HandlerActivity> weakReference ;

        public MyHandler(HandlerActivity activity ){
            weakReference  = new WeakReference<HandlerActivity>( activity) ;
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if ( weakReference.get() != null ){
                // update android ui
                Log.d("mmmmmmmm" , "handler " + msg.what ) ;
            }
        }
    }
}

　　這個Handler已經使用了靜態內部類，並且使用了弱引用。但是這個並沒有完全解決 HandlerActivity 記憶體洩漏的問題，罪魁禍首是執行緒建立的方式出了問題，就像本文的第一個例子一樣。改進的方式，是把Runnable類寫成靜態內部類。

最終完整的程式碼如下：

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.lang.ref.WeakReference;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;
    private static Handler handler ;

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //建立Handler
        handler = new MyHandler( this ) ;

        //建立執行緒並且啟動執行緒
        new Thread( new MyRunnable() ).start();
    }

    private static class MyHandler extends Handler {
        WeakReference<HandlerActivity> weakReference ;

        public MyHandler(HandlerActivity activity ){
            weakReference  = new WeakReference<HandlerActivity>( activity) ;
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if ( weakReference.get() != null ){
                // update android ui
                Log.d("mmmmmmmm" , "handler " + msg.what ) ;
            }
        }
    }

    private static class MyRunnable implements Runnable {

        @Override
        public void run() {
            handler.sendEmptyMessage( MESSAGECODE ) ;
            try {
                Thread.sleep( 8000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            handler.sendEmptyMessage( MESSAGECODE ) ;
        }
    }
}

　　等等，還沒完呢？

上面這個程式碼已經有效的解決了Handler，Runnable 引用Activity例項從而導致記憶體洩漏的問題，但是這不夠。因為記憶體洩漏的核心原因就是這個某個物件應該被系統回收記憶體的時候，卻被其他物件引用，造成該記憶體無法回收。所以我們在寫程式碼的時候，要始終繃著這個弦。再回到上面這個問題，噹噹前Activity呼叫finish銷燬的時候，在這個Activity裡面所有執行緒是不是應該在OnDestory()方法裡，取消執行緒。當然是否取消非同步任務，要看專案具體的需求，比如在Activity銷燬的時候，啟動一個執行緒，非同步寫log日誌到本地磁碟，針對這個需求卻需要在OnDestory()方法裡開啟執行緒。所以根據當前環境做出選擇才是正解。

所以我們還可以修改程式碼為：在onDestroy() 裡面移除所有的callback 和 Message 。

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.lang.ref.WeakReference;

public class HandlerActivity extends AppCompatActivity {

    private final static int MESSAGECODE = 1 ;
    private static Handler handler ;

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

        findViewById( R.id.finish ).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //建立Handler
        handler = new MyHandler( this ) ;

        //建立執行緒並且啟動執行緒
        new Thread( new MyRunnable() ).start();
    }

    private static class MyHandler extends Handler {
        WeakReference<HandlerActivity> weakReference ;

        public MyHandler(HandlerActivity activity ){
            weakReference  = new WeakReference<HandlerActivity>( activity) ;
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if ( weakReference.get() != null ){
                // update android ui
                Log.d("mmmmmmmm" , "handler " + msg.what ) ;
            }
        }
    }

    private static class MyRunnable implements Runnable {

        @Override
        public void run() {
            handler.sendEmptyMessage( MESSAGECODE ) ;
            try {
                Thread.sleep( 8000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            handler.sendEmptyMessage( MESSAGECODE ) ;
        }
    }

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

       //如果引數為null的話，會將所有的Callbacks和Messages全部清除掉。
        handler.removeCallbacksAndMessages( null );
    }
}

　　

 

 

4、AsyncTask造成記憶體洩漏

package rxnet.zyj.com.myapplication;

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

public class Activity2 extends AppCompatActivity {

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

        findViewById( R.id.finish2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });


        new AsyncTask<String,Integer,String>(){

            @Override
            protected String doInBackground(String... params) {
                try {
                    Thread.sleep( 6000 );
                } catch (InterruptedException e) {
                }
                return "ssss";
            }

            @Override
            protected void onPostExecute(String s) {
                super.onPostExecute(s);
                Log.d( "mmmmmm activity2 " , "" + s ) ;
            }

        }.executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR , "" ) ;
        
    }
}

　　為什麼？

上面程式碼在activity中建立了一個匿名類AsyncTask，匿名類和非靜態內部類相同，會持有外部類物件，這裡也就是activity，因此如果你在Activity裡宣告且例項化一個匿名的AsyncTask物件，則可能會發生記憶體洩漏，如果這個執行緒在Activity銷燬後還一直在後臺執行，那這個執行緒會繼續持有這個Activity的引用從而不會被GC回收，直到執行緒執行完成。

   怎麼解決？

  •  自定義靜態AsyncTask類
  • AsyncTask的週期和Activity週期保持一致。也就是在Activity生命週期結束時要將AsyncTask cancel掉。

 

package rxnet.zyj.com.myapplication;

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

public class AsyncTaskActivity extends AppCompatActivity {

    private static MyTask myTask ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_asynctask);

        findViewById( R.id.finish).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        myTask = new MyTask() ;
        myTask.executeOnExecutor( AsyncTask.THREAD_POOL_EXECUTOR , "") ;

    }

    private static class MyTask extends AsyncTask{

        @Override
        protected Object doInBackground(Object[] params) {
            try {
                //模擬耗時操作
                Thread.sleep( 15000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "";
        }
    }

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

        //取消非同步任務
        if ( myTask != null ){
            myTask.cancel(true ) ;
        }
    }
}

 

5、Timer Tasks 造成記憶體洩漏

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;

import java.util.Timer;
import java.util.TimerTask;

public class TimerActivity extends AppCompatActivity {

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

        findViewById( R.id.finish2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //開始定時任務
        timer();
    }

    void timer(){
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                while(true);
            }
        },1000 );  // 1秒後啟動一個任務
    }
}

　　

  為什麼？ 

這裡記憶體洩漏在於Timer和TimerTask沒有進行Cancel，從而導致Timer和TimerTask一直引用外部類Activity。

  怎麼解決？ 

  • 在適當的時機進行Cancel。
  • TimerTask用靜態內部類

   注意：在網上看到一些資料說，解決TimerTask記憶體洩漏可以使用在適當的時機進行Cancel。經過測試，證明單單使用在適當的時機進行Cancel ， 還是有記憶體洩漏的問題。所以一定要用靜態內部類配合使用。

package rxnet.zyj.com.myapplication;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import java.util.Timer;
import java.util.TimerTask;

public class TimerActivity extends AppCompatActivity {

    private TimerTask timerTask ;

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

        findViewById( R.id.finish2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                finish();
            }
        });

        //開始定時任務
        timer();
    }

    void timer(){
        timerTask = new MyTimerTask() ;
        new Timer().schedule( timerTask ,1000 );  // 1秒後啟動一個任務
    }

    private static class MyTimerTask extends TimerTask{

        @Override
        public void run() {
            while(true){
                Log.d( "ttttttttt" , "timerTask" ) ;
            }
        }
    }

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

        //取消定時任務
        if ( timerTask != null ){
            timerTask.cancel() ;
        }
    }
}

 原文連結：

http://www.cnblogs.com/zhaoyanjun/p/5981386.html#

相關推薦

轉 Android SDK Manager國內無法更新的解決方案（親測有效）

轉自 Android SDK Manager國內無法更新的解決方案（親測有效） 現在由於GWF，google基本和咱們說咱見了，就給現在在做Android 或者想學習Android 的朋友帶來了諸多的不便，最簡單的就是Android SDK Manager 你無法更新了。 現在這裡有一

eclipse 匯入 android 專案紅叉和紅色感嘆號怎麼解決（親測有效）

解決辦法如下： 第一步：你要確保這個專案沒有問題，有的專案本身就有問題，例如：xml 檔案，java 程式等本身就有錯。 第二步：在 Eclipse 選單中選擇 “Project”----〉Clean 解決不了，下一步 第三步：右鍵選擇專案，選擇 “Resource----〉Clean u

Android記憶體洩漏查詢和解決adb shell dumpsys meminfo packagement

1.通過adb shell dumpsys meminfo packageName來檢視記憶體使用狀況 在沒有開啟應用的情況下，該命令返回的資料是這樣的: 2.開啟這個應用的MainActivity，再通過命令檢視: 可以看到打印出來很多的資訊，而對於我們檢

Android記憶體洩漏場景及解決方法

本文包括以下內容： 1. 記憶體洩漏原理 2. Android記憶體洩漏發生的情況 3. 檢測記憶體洩漏的工具、方法 4. 如何避免記憶體洩漏 更多Android面試相關請點選 - 四步準備Android面試 - Android開發概要 - 大疆提前批第一次電面

eclipse下Android專案65535方法數限制的完美解決，親測有效

原本以為65535方法數對我來說還很遠，直到專案突然蹦出： java.lang.IllegalArgumentException: method ID not in [0, 0xffff]: 65536 由於專案是由以前的老同事在eclipse環境下搭建的

Android記憶體洩漏定位與解決

問題現象 反覆點選被測試的Android App的toolbar介面，然後返回再點選。在此重複過程中，發現到一定次數時，頁面開啟速度變慢，有時達到5s，十分影響使用者體驗。該問題涉及app所採用的webview框架的所有介面，影響面大。 初步分析 載入介面慢，一

基於Android Studio的記憶體洩漏檢測與解決全攻略

自從Google在2013年釋出了Android Studio後，Android Studio憑藉著自己良好的記憶體優化，酷炫的UI主題，強大的自動補全提示以及Gradle的編譯支援正逐步取代Eclipse，成為主流的Android開發IDE。Android Studio在

有關Android Handler記憶體洩漏分析及解決辦法

1、Android的開發工具是java，這能幫助我們解決很底層的問題 包括：記憶體管理，平臺依賴。然而，有時候專案依然會報OOM錯誤，so垃圾收集器在哪？ 2、我主要研究一種情況：記憶體中較大物件很長一段時間內不能被釋放。這方面並不完全算作記憶體溢位，物件會在某一時間點上被

Android 5.1 WebView記憶體洩漏問題及解決

問題背景 在排查專案記憶體洩漏過程中發現了一些由WebView引起的記憶體洩漏，經過測試發現該部分洩漏只會出現在android 5.1及以上的機型。雖然專案使用WebView的場景並不多，但秉承著一個洩漏都不放過的精神，我們肯定要把它給解決了。 遇到的問題

【轉】Android性能優化-過度繪制解決方案

裏的 watermark == ++ 深度 getc 像素 多次 但是 轉載請註明出處：http://blog.csdn.net/a740169405/article/details/53896497 過度繪制： 屏幕上某一像素點在一幀中被重復繪制多次，就是過度繪制。

【轉】MIUI8以及ViVO X9上在Android Studio運行出錯集及其解決方案

分享圖片 最新版本 ima 運行 測試 mage 安裝 pic com 最近用一臺紅米4高配版(6.0)以及ViVo X9(7.1)來做測試機,它是小米MIUI系統的最新版本MIUI8,我的AS是2.3版本,在網上查看了相關問題,在小米5和紅米note4x等配備了MI

【達內課程】Android中的GC垃圾回收機制與記憶體洩漏

當main()方法執行完，main()方法中的區域性變數都會彈棧，從棧當中銷燬 當左側棧中的e2和e銷燬後，右側中的兩個物件就是垃圾 java底層有一種GC垃圾回收機制，在java程式執行時，GC執行緒會不斷找尋垃圾，是的話會清除掉 當我們點選模擬機的返回鍵時，發生了什麼 當G

解決Android studio編譯大檔案，狂佔記憶體、卡爆的問題

本人使用Android studio3.1進行NDK/JNI開發，遇到編譯一個11.4M的巨大.h檔案(儲存一個5萬行的陣列)，編譯器預設1024M記憶體，完全不夠用，編譯後狂戰記憶體直至卡爆。 解決方法：調整Android studio記憶體設定 Help -> Edit Custo

（Android Studio 3.0）Android Profiler記憶體洩漏檢查

前提概要 記憶體洩漏是常見又重要的問題，針對這個問題谷歌在Android Studio 3.0中推出了Android Profiler。筆者此篇文章主要記錄一下Android Profiler在記憶體洩漏方面的使用。 Android Profiler Android

解決Android呼叫系統相機連續拍照出現的記憶體溢位問題

記憶體溢位相信做過程式設計的人都知道一二，這裡說Android 記憶體溢位的問題：、問題描述：Android下的相機在獨自使用時，拍照沒有問題，通過我們的程式碼呼叫時，也正常，但是更換了不同廠商的平板，ROM由Android4.0變成了Android4.1後，拍照出現了Out

利用Android Studio、MAT對Android進行記憶體洩漏檢測

專案進入維護階段時才有時間測試分析app的記憶體問題,這時就要用到測試工具了,可以使用Android Studio、MAT互相結合進行測試, 但是對於複雜的,這兩者很難分析出來,但這兩測試工具也是必須掌握的,感覺網上大多文章講得不怎麼細緻,所以想寫篇文章記錄下,剛好看到本文

Android list 泛型 用Gson 轉json字串 出現 java.lang.StackOverflowError異常解決

 不廢話 第一次寫部落格，不知道怎麼寫，  直接進入主題 我來這最熟悉的程式碼 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceSt

記憶體優化 . 記憶體洩露 記憶體溢位 記憶體抖動 分析與解決.android stido 工具

記憶體分配 dalvik 5.0之前 art 5.0之後用 根據執行的特定的資料型別 不同分配記憶體 卡頓 是怎麼形成的 卡頓的解決方式 ANR 講下 GC 回收導致 畫面卡頓的問題: 比如自定義view 中 繪製第一個畫面 ,繪製完

Android SDK安裝時出錯“android Failed to rename directory”的解決方法

add size android-s 目錄 解決 androi director lpack lis Android SDK安裝時出錯“android Failed to rename directory”的解決的方法 安裝Android SDK時遇到Faile

Android studio 代碼突然報錯解決方案

cache dst roi image 技術分享 users 方案 file sdn 1.點擊File->Invalidate Caches / Restart... 2.重啟Gradle，清除緩存 3.Clean Project 4.關閉Android Stud