Handler还需要用到弱引用(WeakReference)吗?

于 2018-07-05 19:18:19 发布
阅读量1k 收藏 1
点赞数 2
分类专栏： Android Handler 弱引用
本文探讨了Android中Handler类的正确使用方法以避免内存泄漏，包括如何使用静态内部类和弱引用，以及推荐使用removeCallbacksAndMessages方法。

转自：https://blog.youkuaiyun.com/alcoholdi/article/details/54948058  写的很好



网上很多文章都说写Hanlder，需要用static声明为静态的，还需要用弱引用包裹构造函数传来的Activity实例。

比如这篇英文博客

http://www.androiddesignpatterns.com/2013/01/inner-class-handler-memory-leak.html


里面的Sample是这样写的

  1. public class SampleActivity extends Activity {
  3. /**
  4. * Instances of static inner classes do not hold an implicit
  5. * reference to their outer class.
  6. */
  7. private static class MyHandler extends Handler {
  8. private final WeakReference<SampleActivity> mActivity;
  10. public MyHandler(SampleActivity activity) {
  11. mActivity = new WeakReference<SampleActivity>(activity);
  12. }
  14. @Override
  15. public void handleMessage(Message msg) {
  16. SampleActivity activity = mActivity.get();
  17. if (activity != null) {
  18. // ...
  19. }
  20. }
  21. }
  23. private final MyHandler mHandler = new MyHandler(this);
  25. /**
  26. * Instances of anonymous classes do not hold an implicit
  27. * reference to their outer class when they are "static".
  28. */
  29. private static final Runnable sRunnable = new Runnable() {
  30. @Override
  31. public void run() { /* ... */ }
  32. };
  34. @Override
  35. protected void onCreate(Bundle savedInstanceState) {
  36. super.onCreate(savedInstanceState);
  38. // Post a message and delay its execution for 10 minutes.
  39. mHandler.postDelayed(sRunnable, 1000 * 60 * 10);
  41. // Go back to the previous Activity.
  42. finish();
  43. }
  44. }

post，postDelayed这种传Runnable的方法是不会触发handleMessage方法的。

所以用一下sendEmptyMessageDelayed测试一下

  1. public class SampleActivity extends Activity {
  3. private ImageView iv;
  5. /**
  6. * Instances of static inner classes do not hold an implicit
  7. * reference to their outer class.
  8. */
  9. private static class MyHandler extends Handler {
  10. private final WeakReference<SampleActivity> mActivity;
  12. public MyHandler(SampleActivity activity) {
  13. mActivity = new WeakReference<SampleActivity>(activity);
  14. }
  16. @Override
  17. public void handleMessage(Message msg) {
  18. SampleActivity activity = mActivity.get();
  19. Log.e("YAO", "MyHandler - handleMessage ------ 消息到达了 activity!=null:" + (activity != null));
  20. if (activity != null) {
  21. // ...
  22. }
  23. }
  24. }
  26. private final MyHandler mHandler = new MyHandler(this);
  28. /**
  29. * Instances of anonymous classes do not hold an implicit
  30. * reference to their outer class when they are "static".
  31. */
  32. // private static final Runnable sRunnable = new Runnable() {
  33. // @Override
  34. // public void run() { /* ... */ }
  35. // };
  37. @Override
  38. protected void onCreate(Bundle savedInstanceState) {
  39. super.onCreate(savedInstanceState);
  41. //塞一张大一点的图片,用来增大Activity的所需内存,可以更好的查看Memory趋势图
  42. iv = new ImageView(this);
  43. iv.setImageResource(R.drawable.demo);
  45. // Post a message and delay its execution for 10 minutes.
  46. //mHandler.postDelayed(sRunnable, 1000 * 60 * 10);
  47. mHandler.sendEmptyMessageDelayed(0, 1000L * 30);
  49. // Go back to the previous Activity.
  50. finish();
  51. }
  52. }

打开这个Activity后会自动finish，然后点一下Android Monitor里面的Initiate GC按钮，触发GC操作。


此时Dump Java Heap看看内存情况


可以看到SampleActivity已经被回收了，什么都没有。


而里面的MyHandler还存在，这里还可以看到Handler只持有一个Message对象。

等了30秒消息到达后，日志打印出

02-11 15:22:15.033 7153-7153/com.yao.memorytest E/YAO: MyHandler - handleMessage ------ 消息到达了  activity!=null:false

说明SampleActivity已经被回收了。



重来一次，这次不点击Initiate GC按钮，Dump Java Heap后



对比前面两张图，可以看到SampleActivity还存在。从MyHandler看，这个实例除了有一个Message对象，还有一个SampleActivity对象（注意这个对象是红色的）。

等30秒结果打印出

02-11 15:24:15.033 7153-7153/com.yao.memorytest E/YAO: MyHandler - handleMessage ------ 消息到达了  activity!=null:true

说明关闭页面30秒后，弱引用Activity还在。



如果把static关键字去掉


由于非静态内部类会持有外部类的一个隐式引用。所以MyHandler持有一个当前SampleActivity对象实例（此时这个对象是白色的）。


可以看到，对于static内部类，用弱引用都会把SampleActivity标成红色。而不用static关键字，则是白色。

猜测一下，红色代表的是待回收内存，下次GC后会被回收。白色代表还在使用，GC后不会被回收的内存。



改写一下代码，现在改成使用postDelayed方法，此时按照之前得出的结论Runnable也必须是静态的。

如果Runnable里面有跟当前Activity相关的代码，也得加个弱引用Activity。

  1. public class SampleTwoActivity extends Activity {
  3. private ImageView iv;
  5. /**
  6. * Instances of static inner classes do not hold an implicit
  7. * reference to their outer class.
  8. */
  9. private static class MyHandler extends Handler {
  10. // private final WeakReference<SampleTwoActivity> mActivity;
  11. //
  12. // public MyHandler(SampleTwoActivity activity) {
  13. // mActivity = new WeakReference<SampleTwoActivity>(activity);
  14. // }
  15. //
  16. // @Override
  17. // public void handleMessage(Message msg) {
  18. // SampleTwoActivity activity = mActivity.get();
  19. // Log.e("YAO", "MyHandler - handleMessage ------ 消息到达了 activity!=null:" + (activity != null));
  20. // if (activity != null) {
  21. // // ...
  22. // }
  23. // }
  24. }
  26. private final MyHandler mHandler = new MyHandler();
  28. /**
  29. * Instances of anonymous classes do not hold an implicit
  30. * reference to their outer class when they are "static".
  31. */
  32. private static class MyRunnable implements Runnable {
  34. private final WeakReference<SampleTwoActivity> mActivity;
  36. public MyRunnable(SampleTwoActivity activity) {
  37. mActivity = new WeakReference<SampleTwoActivity>(activity);
  38. }
  40. @Override
  41. public void run() {
  42. SampleTwoActivity activity = mActivity.get();
  43. Log.e("YAO", "MyRunnable - run ------ 执行延时Runnable activity!=null:" + (activity != null));
  44. if (activity != null) {
  45. activity.iv.setVisibility(View.VISIBLE);
  46. }
  47. }
  48. }
  50. private final MyRunnable mMyRunnable = new MyRunnable(this);
  52. @Override
  53. protected void onCreate(Bundle savedInstanceState) {
  54. super.onCreate(savedInstanceState);
  56. //塞一张大一点的图片,用来增大Activity的所需内存,可以更好的查看Memory趋势图
  57. iv = new ImageView(this);
  58. iv.setImageResource(R.drawable.demo);
  60. // Post a message and delay its execution for 10 minutes.
  61. mHandler.postDelayed(mMyRunnable, 1000L * 30);
  62. //mHandler.sendEmptyMessageDelayed(0, 1000L * 30);
  64. // Go back to the previous Activity.
  65. finish();
  66. }
  67. }

Dump Java Heap看看


MyRunnable也持有一个Activity的弱引用，红色的。执行一下GC，Activity也意料之中的被回收了。

等30秒结果打印出

02-12 03:31:18.215 7501-7501/com.yao.memorytest E/YAO: MyRunnable - run ------ 执行延时Runnable  activity!=null:false



以上是发送用Handler发送延时消息，延时任务的情况。

可以看出用上静态内部类+弱引用Handler的确能解决内存泄露的问题，同时得注意Runnable也需要用上静态弱引用才行。



然而有个更好的方法removeCallbacksAndMessages

  1. public class SampleFourActivity extends Activity {
  3. private ImageView iv;
  5. private class MyHandler extends Handler {
  7. @Override
  8. public void handleMessage(Message msg) {
  9. Log.e("YAO", "MyHandler - handleMessage ------ 消息到达了");
  10. iv.setVisibility(View.VISIBLE);
  11. }
  12. }
  14. private final MyHandler mHandler = new MyHandler();
  16. @Override
  17. protected void onCreate(Bundle savedInstanceState) {
  18. super.onCreate(savedInstanceState);
  20. //塞一张大一点的图片,用来增大Activity的所需内存,可以更好的查看Memory趋势图
  21. iv = new ImageView(this);
  22. iv.setImageResource(R.drawable.demo);
  24. // Post a message and delay its execution for 10 minutes.
  25. //mHandler.postDelayed(sRunnable, 1000 * 60 * 10);
  26. mHandler.sendEmptyMessageDelayed(0, 1000L * 30);
  28. // Go back to the previous Activity.
  29. finish();
  30. }
  32. @Override
  33. protected void onDestroy() {
  34. super.onDestroy();
  35. mHandler.removeCallbacksAndMessages(null);
  36. }
  37. }
只需要在onDestroy里面Handler.removeCallbacksAndMessages(null);，无论runnbale还是message消息全清空，自然也不会关联上Activity。下次GC就能顺利回收了。


发送长时间的延时消息/任务其实是少见，更多的是比如我们经常开线程联网访问或者开线程做一些耗时计算，结束后才通过Handler发送消息更新UI，应该是这样的。

  1. public class SampleThreeActivity extends Activity {
  3. private ImageView iv;
  5. /**
  6. * Instances of static inner classes do not hold an implicit
  7. * reference to their outer class.
  8. */
  9. private static class MyHandler extends Handler {
  11. }
  13. private final MyHandler mHandler = new MyHandler();
  15. /**
  16. * Instances of anonymous classes do not hold an implicit
  17. * reference to their outer class when they are "static".
  18. */
  19. private static class MyRunnable implements Runnable {
  21. private final WeakReference<SampleThreeActivity> mActivity;
  23. public MyRunnable(SampleThreeActivity activity) {
  24. mActivity = new WeakReference<SampleThreeActivity>(activity);
  25. }
  27. @Override
  28. public void run() {
  29. Log.e("YAO", "TestMemoryActivity.java - run() ---------- 工作线程正在执行耗时任务....");
  30. SystemClock.sleep(1000L * 30);
  31. SampleThreeActivity activity = mActivity.get();
  32. Log.e("YAO", "MyRunnable - run ------ 执行延时Runnable activity!=null:" + (activity != null));
  33. if (activity != null) {
  34. activity.mHandler.obtainMessage().sendToTarget();
  35. }
  36. }
  37. }
  39. private final MyRunnable mMyRunnable = new MyRunnable(this);
  41. @Override
  42. protected void onCreate(Bundle savedInstanceState) {
  43. super.onCreate(savedInstanceState);
  45. //塞一张大一点的图片,用来增大Activity的所需内存,可以更好的查看Memory趋势图
  46. iv = new ImageView(this);
  47. iv.setImageResource(R.drawable.demo);
  49. // Post a message and delay its execution for 10 minutes.
  50. //mHandler.postDelayed(mMyRunnable, 1000 * 30);
  51. //mHandler.sendEmptyMessageDelayed(0, 1000L * 30);
  52. new Thread(mMyRunnable).start();
  54. // Go back to the previous Activity.
  55. finish();
  56. }
  57. }

Dump Java Heap


发现Activity是红色的可回收内存，没啥问题。

但是改一下run方法里面的代码。

  1. @Override
  2. public void run() {
  3. SampleThreeActivity activity = mActivity.get();
  4. if (activity != null) {
  5. //通过弱引用去获取Activity的成员变量参数(比如网址url)，再跑耗时任务。
  6. String url = activity.url;
  7. Log.e("YAO", "TestMemoryActivity.java - run() ---------- 工作线程正在执行耗时任务....");
  8. SystemClock.sleep(1000L * 30);
  9. activity.mHandler.obtainMessage().sendToTarget();
  10. }
  11. }


所以用了弱引用的get方法后，相当于会把内存中的弱引用转为强引用。


所以如果是这种方式的话，建议退出这个Activity时取消这个任务。Thread是没有提供取消任务的方法的。可以用AsyncTask的cancel方法，ExecutorService的shutdown方法，当然一般网络框架volley、okhttp这些也会提供相应的取消请求方法。

（较真一点如果在使用AsyncTask时也改成静态内部类+弱引用当然也可以，但是非常麻烦，AsyncTask运行在UI线程的onPreExecute、onProgressUpdate、onPostExecute使用到Activity中的成员变量的话，都需要进行弱引用Activity的判空方法，相当麻烦。）

  1. static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
  3. private final WeakReference<SampleFiveActivity> mActivity;
  5. public MyAsyncTask(SampleFiveActivity activity) {
  6. mActivity = new WeakReference<SampleFiveActivity>(activity);
  7. }
  9. @Override
  10. protected void onPreExecute() {
  11. SampleFiveActivity activity = mActivity.get();
  12. Log.e("YAO", "MyAsyncTask - onPreExecute ------ activity!=null:" + (activity != null));
  13. if (activity != null) {
  14. activity.iv.setVisibility(View.VISIBLE);
  15. }
  16. }
  18. @Override
  19. protected Void doInBackground(Void... params) {
  20. Log.e("YAO", "TestMemoryActivity.java - run() ---------- 工作线程正在执行耗时任务....");
  21. SystemClock.sleep(1000L * 30);
  22. return null;
  23. }
  25. @Override
  26. protected void onPostExecute(Void aVoid) {
  27. SampleFiveActivity activity = mActivity.get();
  28. Log.e("YAO", "MyAsyncTask - onPostExecute ------ activity!=null:" + (activity != null));
  29. if (activity != null) {
  30. activity.iv.setVisibility(View.VISIBLE);
  31. }
  32. }
  33. }



总结就是，以后我使用handler估计只会用Handler.removeCallbacksAndMessages(null);这种方法了，方便快捷。


评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值