安卓内存泄漏的原因

一：单例设计模式造成的内存泄漏：

单例设计模式我就不多说了，这个是最基本的设计模式，相信大家都会使用，但是时候我们在使用单例设计模式时没有注意到其中的细节，就会造成内存泄漏。

单例设计模式的静态特性会使他的生命周期和应用程序的生命周期一样长，这就说明了如果一个对象不在使用了，而这时单例对象还在持有该对象的引用，这时GC就会无法回收该对象，造成了内存泄露的情况。

 下面是错误的单例设计模式的代码：

1. public class AppManager {

2. private static AppManager instance;

3. private Context context;

4. private AppManager(Context context) {

5. this.context = context;

6. }

7. public static AppManager getInstance(Context context) {

8. if (instance != null) {

9. instance = new AppManager(context);

10. }

11. return instance;

12. }

13. }

 

上面的代码是一个最普通的单例模式，但是需要注意两个问题：

1、如果我们传入的Context是Application的Context的话，就没有任何问题，因为Application的Context生命周期和应用程序生命周期一样长。

2、如果我们传入的Context是Activity的Context的话，这时如果我们因为需求销毁了该Activity的话，Context也会随着Activity被销毁，但是单例还在持有对该类对象的引用，这时就会造成内存泄漏。

所以，正确的单例模式写法应该是这样的：

 

1. public class AppManager {

2. private static AppManager instance;

3. private Context context;

4. private AppManager(Context context) {

5. this.context = context.getApplicationContext();

6. }

7. public static AppManager getInstance(Context context) {

8. if (instance != null) {

9. instance = new AppManager(context);

10. }

11. return instance;

12. }

13. }

这样的话不管我们传入什么样的Context，最终使用的都是Application的Context，单例的生命周期和应用一样长，这样就不会造成内存泄漏了。

 

二、非静态内部类创建的静态实例造成的内存泄漏

有时候因为需求我们会去频繁的启动一个Activity，这时为了避免频繁的创建相同的数据源，我们通常会做如下处理：

 

 

1. public class MainActivity extends AppCompatActivity {

2.  

3. private static TestResource mResource = null;

4.  

5. @Override

6.  

7. protected void onCreate(Bundle savedInstanceState) {

8.  

9. super.onCreate(savedInstanceState);

10.  

11. setContentView(R.layout.activity_main);

12.  

13. if(mManager == null){

14.  

15. mManager = new TestResource();

16.  

17. }

18.  

19. //...

20.  

21. }

22.  

23. class TestResource {

24.  

25. //...

26.  

27. }

28.  

29. }

 

这样就在Activity中创建了非静态内部类，非静态内部类默认持有Activity类的引用，但是他的生命周期还是和应用程序一样长，所以当Activity销毁时，静态内部类的对象引用不会被GC回收，就会造成了内存溢出，解决办法：

1、将内部类改为静态内部类。

2、将这个内部类封装成一个单例，Context使用Application的Context

 

三、Handler造成的内存泄漏：

先看一下不规范的Handler写法：

 

1. public class MainActivity extends AppCompatActivity {

2. private Handler mHandler = new Handler() {

3. @Override

4. public void handleMessage(Message msg) {

5. //...

6. }

7. };

8. @Override

9. protected void onCreate(Bundle savedInstanceState) {

10. super.onCreate(savedInstanceState);

11. setContentView(R.layout.activity_main);

12. loadData();

13. }

14. private void loadData(){

15. //...request

16. Message message = Message.obtain();

17. mHandler.sendMessage(message);

18. }

19. }

这里的handler也是一个非静态匿名内部类，他跟上面的一样，也会持有Activity的引用，我们知道handler是运行在一个Looper线程中的，而Looper线程是轮询来处理消息队列中的消息的，假设我们处理的消息有十条，而当他执行到第6条的时候，用户点击了back返回键，销毁了当前的Activity，这个时候消息还没有处理完，handler还在持有Activity的引用，这个时候就会导致无法被GC回收，造成了内存泄漏。正确的做法是：

 

1. public class MainActivity extends AppCompatActivity {

2. //new一个自定义的Handler

3. private MyHandler mHandler = new MyHandler(this);

4. private TextView mTextView ;

5.  

6. //自定义静态内部类继承自Handler

7. private static class MyHandler extends Handler {

8. private WeakReference<Context> reference;

9. //在构造函数中使用弱引用来引用context对象

10. public MyHandler(Context context) {

11. reference = new WeakReference<>(context);

12. }

13. @Override

14. public void handleMessage(Message msg) {

15. MainActivity activity = (MainActivity) reference.get();

16. if(activity != null){

17. activity.mTextView.setText("");

18. }

19. }

20. }

21.  

22. @Override

23. protected void onCreate(Bundle savedInstanceState) {

24. super.onCreate(savedInstanceState);

25. setContentView(R.layout.activity_main);

26. mTextView = (TextView)findViewById(R.id.textview);

27. loadData();

28. }

29.  

30. private void loadData() {

31. //...request

32. Message message = Message.obtain();

33. mHandler.sendMessage(message);

34. }

35.  

36. @Override

37. protected void onDestroy() {

38. super.onDestroy();

39. //移除队列中所有的Runable和消息

40. //这里也可以使用mHandler.removeMessage和mHandler.removeCallBacks来移除指定的Message和Runable

41. mHandler.removeCallbacksAndMessages(null);

42. }

43. }

 

创建一个静态内部类继承自handler，然后再在构造参数中对handler持有的对象做弱引用，这样在回收时就会回收了handler持有的对象，这里还做了一处修改，就是当我

们的回收了handler持有的对向，即销毁了该Activity时，这时如果handler中的还有未处理的消息，我们就需要在OnDestry方法中移除消息队列中的消息。

 

 

四、线程造成的内存泄漏

线程使用不恰当造成的内存泄漏也是很常见的，下面举两个例子：

1. //——————test1

2. new AsyncTask<Void, Void, Void>() {

3. @Override

4. protected Void doInBackground(Void... params) {

5. SystemClock.sleep(10000);

6. return null;

7. }

8. }.execute();

9. //——————test2

10. new Thread(new Runnable() {

11. @Override

12. public void run() {

13. SystemClock.sleep(10000);

14. }

15. }).start();

上面是两个内部类，当我们的Activity销毁时，这两个任务没有执行完毕，就会使Activity的内存资源无法被回收，造成了内存泄漏。

正确的做法是使用静态内部类：如下

1. static class MyAsyncTask extends AsyncTask<Void, Void, Void> {

2. private WeakReference<Context> weakReference;

3.  

4. public MyAsyncTask(Context context) {

5. weakReference = new WeakReference<>(context);

6. }

7.  

8. @Override

9. protected Void doInBackground(Void... params) {

10. SystemClock.sleep(10000);

11. return null;

12. }

13.  

14. @Override

15. protected void onPostExecute(Void aVoid) {

16. super.onPostExecute(aVoid);

17. MainActivity activity = (MainActivity) weakReference.get();

18. if (activity != null) {

19. //...

20. }

21. }

22. }

23. static class MyRunnable implements Runnable{

24. @Override

25. public void run() {

26. SystemClock.sleep(10000);

27. }

28. }

29. //——————

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

31. new MyAsyncTask(this).execute();

这样就避免了内存泄漏，当然在Activity销毁时也要记得在OnDestry中调用AsyncTask.cancal()方法来取消相应的任务。避免在后台运行浪费资源。

 

五、资源未关闭造成的内存泄漏

在使用完BraodcastReceiver,ContentObserver,File,Cursor,Stream,Bitmap等资源时，一定要在Activity中的OnDestry中及时的关闭、注销或者释放内存，

否则这些资源不会被GC回收，就会造成内存泄漏。