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

　

weakreference

转自：HTTPs://blog.csdn.net/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);这种方法了，方便快捷。

相关阅读