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

最新推荐文章于 2021-09-13 14:43:29 发布
最新推荐文章于 2021-09-13 14:43:29 发布
阅读量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);这种方法了，方便快捷。


Handler持有Activity的泄露解决:静态内部类+弱引用
自带橡皮的铅笔的博客
03-08 1951
在处理handle异步消息处理机制中，我们经常会写出如下代码： public class HandlerTestActivity extends Activity { private final Handler mHandler = new Handler() { @Override public void handleMessage(Message msg...
面试官问：Handler内存泄露的场景，别就只知道静态内部类&弱引用……
weixin_55362248的博客
03-22 254
我们在编码的过程中，如果出现疏忽或错误，造成程序未能释放已经不再使用的内存，就会导致内存泄露，随着泄露内存的增长，最终一定会导致 OOM。 在 JVM 中，对对象的回收 GC 是基于可达性分析。简单来说，就是从 GC Root 出发，被引用的对象均被标记为存活，而没有被引用的对象，则被标记为垃圾，即可以被 GC 回收。 那么如果出现内存泄露，可以理解为就是一个长生命周期的对象，引用了短生命周期的对象，导致短生命周期的对象，在生命周期结束后，仍然得不到回收，最终导致内存泄露。 而 Handler 若是使用不当
android中关于弱引用，This Handler class should be static or leaks might occur
yujina2008的专栏
02-28 758
转载地址：http://hi.baidu.com/cenxcen/item/91ef79985d5c2532336eebc1 更新到adt2.0的开发者们可能会在handler上发现这么一条警告：This Handler class should be static or leaks might occur 。 首先在ADT 20 Changes我们可以找到这样一个变化：New Lint Ch
Handler使用WeakReference
u010588886的专栏
08-15 988
public class HandlerActivity extends Activity {private String string = "string";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);new Thread(new Runnable(
Android 优化之handler弱引用
weixin_44021334的博客
01-05 3341
Android 开发的小伙伴都知道， 典型的开发场景就是用 Handler 来更新UI或者做一些简单耗时的操作。 举个例子，这样一写就完成了。 Handler mHandler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); switch (msg.what
handler 弱引用
devin的专栏
09-08 650
handler比较容易造成内存泄漏，所以进行改进 @SuppressWarnings("unused") public class WeakHandler { private final Handler.Callback mCallback; // hard reference to Callback. We need to keep callback in memory p
java常见面试考点（二十四）：强引用，软引用，虚引用，弱引用
qq_44159782的博客
05-14 405
java常见面试考点 往期文章推荐：   java常见面试考点（十九）：redis在项目中的使用场景   java常见面试考点（二十）：Elasticsearch 和 solr 的区别   java常见面试考点（二十一）：单点登录   java常见面试考点（二十二）：购物车实现   java常见面试考点（二十三）：消息队列 【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）； 本博客的内容来自于：； 学习、合作与交流联系q384660495； 本博客的内容仅供学习与参考，并非营利；
使用Handler容易产生的内存泄露以及介绍下Java的4种引用
王亟亟的博客
04-27 4292
转载请注明出处：王亟亟的大牛之路最近时间都利用的不太好，都是到下午才开始学习或者做事，一上午都吹B或者XXX用掉了。。。不太好，这里督促下自己不要再懒惰，哈哈！！再安利下我的整合库，方便大家找资源：https://github.com/ddwhan0123/Useful-Open-Source-Android废话不多说，今天来讲下一个“经常”遇到的一个内存泄露的情况来引出想提的Java的4种引用方式
强引用 软引用 弱引用 虚引用
最新发布
03-12
好的，我现在需要回答用户关于Java中四种引用类型（强引用、软引用、弱引用、虚引用）的区别和应用场景的问题。首先，我得回忆一下这些引用的基本概念，然后整理它们的区别和实际应用。 首先，强引用是最常见的，...
Android中使用Handler造成内存泄露的分析和解决
weixin_34342905的博客
12-04 455
2019独角兽企业重金招聘Python工程师标准>>> ...
弱引用Handler
战歌起
09-13 366
handler 导致内存泄漏问题很常见，因此需要让它弱引用 context。如下处理一下更好用 消息处理回调接口 public interface IMessageConsumer { //消费事件 void handleMessage(Message msg); } 弱引用包装 public class WeakHandler extends Handler { private final WeakReference<IMessageConsumer> co
Handler 容易造成内存泄漏，结合WeakReference 弱引用有效减少内存泄漏的情况
工宗浩生财指南针
04-03 498
常见内存泄露的原因 •非静态匿名内部类和非静态内部类会引用外部类。 •回调有可能会引起内存泄露，如果回调对象被静态对象引用或者其他原因引用而无法释放，就会导致内存泄露。 •非静态Handler引用外部类引起内存泄露 •线程，动画等无限循环执行，引用了需要释放的对象，也会引起内存泄露 •静态成员集合类和静态View对象 以及静态的非静态成员变量 •单例类 •资源未关闭导致的泄露。 如果引用...
Android handler（工具类）弱引用 WeakReference
zhengyongbo的博客
04-11 4158
转载：(http://blog.youkuaiyun.com/android_zhengyongbo/article/details/70046398) handler弱引用可以在一定程度上防止内存泄露handler弱引用的工具类import android.os.Handler; import android.os.Message;import java.lang.ref.WeakReference;/*
【Android+Kotlin】WeakReference与Handler小结
qq_38304672的博客
02-03 2360
扉：看了许多文章，大多是讲WeakReference原理的，但没有说明项目中具体的使用 目前了解到WeakReference比较适合用于处理Handler的内存泄漏(实际上会强持有activity的引用，而强引用处理不当容易引起内存泄漏) 一：声明 WeakReference 学习和使用 强引用(New)、软引用(SoftReference )、弱引用(WeakReference )、虚引用(PhantomReference) ...
Android Handler内部类+WeakReference
Ti_wj的博客
07-14 831
Handler： 普通用法： Handler用于处理和从队列MessageQueue中得到Message。一般我们要重写Handler的handleMessage(Message msg){}方法来处理，如下代码： public class MainActivity extends Activity { private TextView textView; Handler
Android WeakReference的应用：自定义Handler : WeakHandler
欢迎来到Cozing的博客
08-16 2572
背景：     WeakReference（弱引用）作用：防止被强引用的对象的内存不被释放。     android开发中使用Handler出现的情况，比如在Activity内部new一个Handler： Handler mHandler = new Handler(){ @Override public void handl...
android中handler使用WeakReference防止内存泄露
liangde123的博客
04-13 418
转自：http://www.linuxidc.com/Linux/2013-12/94065.htm 什么是内存泄露？ Java使用有向图机制，通过GC自动检查内存中的对象（什么时候检查由虚拟机决定），如果GC发现一个或一组对象为不可到达状态，则将该对象从内存中回收。也就是说，一个对象不被任何引用所指向，则该对象会在被GC发现的时候被回收；另外，如果一组对象中只包含互相的引用，而没
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值