查看: 2418|回复: 0

[Android教程] Android基础夯实--你了解Handler有多少?

发表于 2018-1-11 08:00:00
概述

对于刚入门的同学来说,往往都会对Handler比较迷茫,到底Handler是个什么样的东西。当然,可能对于一些有工作经验的工程师来说,他们也不一定能很准确地描述,我们来看下API的介绍。

Handler是用来结合线程的消息队列来发送、处理“Message对象”和“Runnable对象”的工具。每一个Handler实例之后会关联一个线程和该线程的消息队列。当你创建一个Handler的时候,从这时开始,它就会自动关联到所在的线程/消息队列,然后它就会陆续把Message/Runnalbe分发到消息队列,并在它们出队的时候处理掉。

从官方文档中,我们不难找出其中的关键词,就是“线程”。我们都知道,一个涉及到网络操作,耗时操作等的Android应用,都离不开多线程操作,然而,如果这时我们允许并发更新UI,那么最终导致控件的状态都是不可确定的。所以,我们可以通过对控件进行加锁,在不需要用时解锁,这是一个解决方案之一,但最后很容易造成线程阻塞,效率会非常差。所以,谷歌采用了只允许在主线程更新UI,所以作为线程通信桥梁的Handler也就应运而生了。

Looper、MessageQueue、Message、Handler的关系

讲到Handler,肯定离不开Looper、MessageQueue、Message这三者和Handler之间的关系,下面简略地带过,详细自己可以查阅相关资料,或者查看源码,这样更方便大家深入学习。

Looper

每一个线程只有一个Looper,每个线程在初始化Looper之后,然后Looper会维护好该线程的消息队列,用来存放Handler发送的Message,并处理消息队列出队的Message。它的特点是它跟它的线程是绑定的,处理消息也是在Looper所在的线程去处理,所以当我们在主线程创建Handler时,它就会跟主线程唯一的Looper绑定,从而我们使用Handler在子线程发消息时,最终也是在主线程处理,达到了异步的效果。

那么就会有人问,为什么我们使用Handler的时候从来都不需要创建Looper呢?这是因为在主线程中,ActivityThread默认会把Looper初始化好,prepare以后,当前线程就会变成一个Looper线程。

MessageQueue

MessageQueue是一个消息队列,用来存放Handler发送的消息。每个线程最多只有一个MessageQueue。MessageQueue通常都是由Looper来管理,而主线程创建时,会创建一个默认的Looper对象,而Looper对象的创建,将自动创建一个MessageQueue。其他非主线程,不会自动创建Looper。

Message

消息对象,就是MessageQueue里面存放的对象,一个MessageQueu可以包括多个Message。当我们需要发送一个Message时,我们一般不建议使用new Message()的形式来创建,更推荐使用Message.obtain()来获取Message实例,因为在Message类里面定义了一个消息池,当消息池里存在未使用的消息时,便返回,如果没有未使用的消息,则通过new的方式创建返回,所以使用Message.obtain()的方式来获取实例可以大大减少当有大量Message对象而产生的垃圾回收问题。

四者关系总体如下(如有不对的地方,谢谢指出)
image

Handler的主要用途
  1. 推送未来某个时间点将要执行的Message或者Runnable到消息队列。
  2. 在子线程把需要在另一个线程执行的操作加入到消息队列中去。

废话不多说,通过举例来说明Handler的两个主要用途。

1. 推送未来某个时间点将要执行的Message或者Runnable到消息队列

实例:通过Handler配合Message或者Runnable实现倒计时

  • 首先看一下效果图

image

  • 方法一,通过Handler + Message的方式实现倒计时。代码如下:
  1. public class MainActivity extends AppCompatActivity {
  2. private ActivityMainBinding mBinding;
  3. private Handler mHandler ;
  4. @Override
  5. protected void onCreate(Bundle savedInstanceState) {
  6. super.onCreate(savedInstanceState);
  7. mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);
  8. //设置监听事件
  9. mBinding.clickBtn.setOnClickListener(new View.OnClickListener() {
  10. @Override
  11. public void onClick(View v) {
  12. //通过Handler + Message的方式实现倒计时
  13. for (int i = 1; i <= 10; i++) {
  14. Message message = Message.obtain(mHandler);
  15. message.what = 10 - i;
  16. mHandler.sendMessageDelayed(message, 1000 * i); //通过延迟发送消息,每隔一秒发送一条消息
  17. }
  18. }
  19. });
  20. mHandler = new Handler() {
  21. @Override
  22. public void handleMessage(Message msg) {
  23. super.handleMessage(msg);
  24. mBinding.time.setText(msg.what + ""); //在handleMessage中处理消息队列中的消息
  25. }
  26. };
  27. }
  28. }
复制代码

其实代码不用怎么解释,都比较通俗易懂,但是这里用到了DataBiding,可能没用过的同学看起来有点奇怪,但其实反而简略了代码,有一定基础的同学看起来都不会有太大压力,所以不做太多解释。通过这个小程序,作者希望大家可以了解到Handler的一个作用就是,在主线程中,可以通过Handler来处理一些有顺序的操作,让它们在固定的时间点被执行。

  • 方法二,通过Handler + Runnable的方式实现倒计时。代码如下:
  1. public class MainActivity extends AppCompatActivity {
  2. private ActivityMainBinding mBinding;
  3. private Handler mHandler = new Handler();
  4. @Override
  5. protected void onCreate(Bundle savedInstanceState) {
  6. super.onCreate(savedInstanceState);
  7. mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);
  8. //设置监听事件
  9. mBinding.clickBtn.setOnClickListener(new View.OnClickListener() {
  10. @Override
  11. public void onClick(View v) {
  12. for (int i = 1; i <= 10; i++) {
  13. final int fadedSecond = i;
  14. //每延迟一秒,发送一个Runnable对象
  15. mHandler.postDelayed(new Runnable() {
  16. @Override
  17. public void run() {
  18. mBinding.time.setText((10 - fadedSecond) + "");
  19. }
  20. }, 1000 * i);
  21. }
  22. }
  23. });
  24. }
  25. }
复制代码

方法二也是通过代码让大家加深Handler处理有序事件的用途,之所以分开Runnable和Message两种方法来实现,是因为很多人都搞不清楚为什么Handler可以推送Runnable和Message两种对象。其实,无论Handler将Runnable还是Message加入MessageQueue,最终都只是将Message加入到MessageQueue。只要大家看一下源码就可以知道,Handler的post Runnable对象这个方法只是对post Message进行了一层封装,所以最终我们都是通过Handler推送了一个Message罢了,至于为什么会分开两种方法,下文会给大家详说究竟。下面再来看看Handler的第二个主要用途。

2. 在子线程把需要在另一个线程执行的操作加入到消息队列中去

实例:通过Handler + Message来实现子线程加载图片,在UI线程显示图片

  • 效果图如下

image

  • 代码如下(布局代码也不放出来了)
  1. public class ThreadActivity extends AppCompatActivity implements View.OnClickListener {
  2. private ActivityThreadBinding mBinding = null;
  3. @Override
  4. protected void onCreate(Bundle savedInstanceState) {
  5. super.onCreate(savedInstanceState);
  6. mBinding = DataBindingUtil.setContentView(this, R.layout.activity_thread);
  7. // 设置点击事件
  8. mBinding.clickBtn.setOnClickListener(this);
  9. mBinding.resetBtn.setOnClickListener(this);
  10. }
  11. @Override
  12. public void onClick(View v) {
  13. switch (v.getId()) {
  14. // 响应load按钮
  15. case R.id.clickBtn:
  16. // 开启一个线程
  17. new Thread(new Runnable() {
  18. @Override
  19. public void run() {
  20. // 在Runnable中进行网络读取操作,返回bitmap
  21. final Bitmap bitmap = loadPicFromInternet();
  22. // 在子线程中实例化Handler同样是可以的,只要在构造函数的参数中传入主线程的Looper即可
  23. Handler handler = new Handler(Looper.getMainLooper());
  24. // 通过Handler的post Runnable到UI线程的MessageQueue中去即可
  25. handler.post(new Runnable() {
  26. @Override
  27. public void run() {
  28. // 在MessageQueue出队该Runnable时进行的操作
  29. mBinding.photo.setImageBitmap(bitmap);
  30. }
  31. });
  32. }
  33. }).start();
  34. break;
  35. case R.id.resetBtn:
  36. mBinding.photo.setImageBitmap(BitmapFactory.decodeResource(getResources(), R.mipmap.default_pic));
  37. break;
  38. }
  39. }
  40. /***
  41. * HttpUrlConnection加载图片,不多说
  42. * @return
  43. */
  44. public Bitmap loadPicFromInternet() {
  45. Bitmap bitmap = null;
  46. int respondCode = 0;
  47. InputStream is = null;
  48. try {
  49. URL url = new URL("https://ss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=1421494343,3838991329&fm=23&gp=0.jpg");
  50. HttpURLConnection connection = (HttpURLConnection) url.openConnection();
  51. connection.setRequestMethod("GET");
  52. connection.setConnectTimeout(10 * 1000);
  53. connection.setReadTimeout(5 * 1000);
  54. connection.connect();
  55. respondCode = connection.getResponseCode();
  56. if (respondCode == 200) {
  57. is = connection.getInputStream();
  58. bitmap = BitmapFactory.decodeStream(is);
  59. }
  60. } catch (MalformedURLException e) {
  61. e.printStackTrace();
  62. Toast.makeText(getApplicationContext(), "访问失败", Toast.LENGTH_SHORT).show();
  63. } catch (IOException e) {
  64. e.printStackTrace();
  65. } finally {
  66. if (is != null) {
  67. try {
  68. is.close();
  69. } catch (IOException e) {
  70. e.printStackTrace();
  71. }
  72. }
  73. }
  74. return bitmap;
  75. }
  76. }
复制代码
Handler推送Message和Runnable的区别

在上文我们通过用Handler推送Message和Runnable实现相同的倒计时效果,这里我们就说一下Post(Runnable)和SendMessage(Message)的区别。

首先我们看看post方法和sendMessage方法的源码:

  1. public final boolean post(Runnable r)
  2. {
  3. return sendMessageDelayed(getPostMessage(r), 0);
  4. }
复制代码
  1. public final boolean sendMessage(Message msg)
  2. {
  3. return sendMessageDelayed(msg, 0);
  4. }
复制代码

可见,两个方法都是通过调用sendMessageDelayed方法实现的,所以可以知道它们的底层逻辑是一致的。

但是,post方法的底层调用sendMessageDelayed的时候,却是通过getPostMessage(r)来将Runnable对象来转为Message,我们点进方getPostMessage()法可以看到:

  1. private static Message getPostMessage(Runnable r) {
  2. Message m = Message.obtain();
  3. m.callback = r;
  4. return m;
  5. }
复制代码

其实,最终runnable最终也是转化为一个Message,而这个Message只有一个被赋值的成员变量,就是Runnable的回调函数,也就是说,这个Message在进入MessageQueue之后,它只是一个“动作”,即我们Runnbale的run方法里面的操作。

要知道,我们的Message类可是有很多参数的,所以你可以理解为它是一个非常丰富的JavaBean,可以看看它的成员变量:

  • public int what;
  • public int arg1;
  • public int arg2;
  • public Object obj;
  • ...

那么讲到这里,大家也应该有所理解为什么Google工程师为什么会封装这两种方法,我总结如为:为了更方便开发者根据不同需要进行调用。当我们需要传输很多数据时,我们可以使用sendMessage来实现,因为通过给Message的不同成员变量赋值可以封装成数据非常丰富的对象,从而进行传输;当我们只需要进行一个动作时,直接使用Runnable,在run方法中实现动作内容即可。当然我们也可以通过Message.obtain(Handler h, Runnable callback)来传入callback接口,但这样看起来就没有post(Ruannable callback)那么直观。

API

API是我们学习最好的文档,所以我也简要跟大家学习一下,其实大家认真看我上面的介绍加上自己亲手实践,Handler的API大家都可以随便翻阅了。

构造函数
  • Handler()
  • Handler(Handler.Callback callback):传入一个实现的Handler.Callback接口,接口只需要实现handleMessage方法。
  • Handler(Looper looper):将Handler关联到任意一个线程的Looper,在实现子线程之间通信可以用到。
  • Handler(Looper looper, Handler.Callback callback)
主要方法
  • void dispatchMessage (Message msg)

一般情况下不会使用,因为它的底层实现其实是作为处理系统消息的一个方法,如果真要用,效果和sendMessage(Message m)效果一样。

  1. public void dispatchMessage(Message msg) {
  2. if (msg.callback != null) {
  3. // 如果有Runnbale,则直接执行它的run方法
  4. handleCallback(msg);
  5. } else {
  6. //如果有实现自己的callback接口
  7. if (mCallback != null) {
  8. //执行callback的handleMessage方法
  9. if (mCallback.handleMessage(msg)) {
  10. return;
  11. }
  12. }
  13. //否则执行自身的handleMessage方法
  14. handleMessage(msg);
  15. }
  16. }
  17. private static void handleCallback(Message message) {
  18. message.callback.run();
  19. }
复制代码
  • void dump (Printer pw, String prefix)

主要Debug时使用的一个方法,dump函数只是使用了Printer对象进行了打印,打印出Handler以及Looper和Queue中的一些信息,源码如下:

  1. public final void dump(Printer pw, String prefix) {
  2. pw.println(prefix + this + " @ " + SystemClock.uptimeMillis());
  3. // 如果Looper为空,输出Looper没有初始化
  4. if (mLooper == null) {
  5. pw.println(prefix + "looper uninitialized");
  6. } else {
  7. // 否则调用Looper的dump方法,Looper的dump方法也是
  8. mLooper.dump(pw, prefix + " ");
  9. }
  10. }
复制代码

通过测试用例大家会了解得更清晰:

  1. //测试代码
  2. Printer pw = new LogPrinter(Log.ERROR, "MyTag");
  3. mHandler.dump(pw, "prefix");
复制代码

结果:
image

  • Looper getLooper ()

拿到Handler相关联的Looper

  • String getMessageName (Message message)

获取Message的名字,默认名字为message.what的值。

  • void handleMessage (Message msg)

处理消息。

  • boolean hasMessages (int what)

判断是否有Message的what值为参数what。

  • boolean hasMessages (int what, Object object)

判断是否有Message的what值为参数what,obj值为参数object。

  • Message obtainMessage (int what, Object obj)

从消息池中拿到一个消息并赋值what和obj,其他重载函数同理。

  • boolean post (Runnable r)

将Runnable对象加入MessageQueue。

  • boolean post (Runnable r)

将Runnbale加入到消息队列的队首。但是官方不推荐这么做,因为很容易打乱队列顺序。

  • boolean postAtTime (Runnable r, Object token, long uptimeMillis)

在某个时间点执行Runnable r。

  • boolean postDelayed (Runnable r, long delayMillis)

当前时间延迟delayMillis个毫秒后执行Runnable r。

  • void removeCallbacks (Runnable r, Object token)

移除MessageQueue中的所有Runnable对象。

  • void removeCallbacksAndMessages (Object token)

移除MessageQueue中的所有Runnable和Message对象。

  • void removeMessages (int what)

移除所有what值得Message对象。

  • boolean sendEmptyMessage (int what)

直接拿到一个空的消息,并赋值what,然后发送到MessageQueue。

  • boolean sendMessageDelayed (Message msg, long delayMillis)

在延迟delayMillis毫秒之后发送一个Message到MessageQueue。

Handler引发的内存泄漏

在上面的例子中,为了展示方便,我都没有考虑内存泄漏的情况,但是在实际开发中,如果不考虑代码的安全性的话,尤其当一个项目到达了一定的规模之后,那么对于代码的维护和系统的调试都是非常困难的。而Handler的内存泄漏在Android中也是一个非常经典的案例。

详细可以参考:How to Leak a Context: Handlers & Inner Classes

或参考翻译文:Android中Handler引起的内存泄露

通常我们都会在一个Activity内部定义一个Handler的内部类:

  1. public class MainActivity extends AppCompatActivity {
  2. private Handler mHandler = new Handler(){
  3. @Override
  4. public void handleMessage(Message msg) {
  5. super.handleMessage(msg);
  6. switch (msg.what){
  7. ...
  8. }
  9. }
  10. };
  11. @Override
  12. protected void onCreate(Bundle savedInstanceState) {
  13. super.onCreate(savedInstanceState);
  14. mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);
  15. mHandler.postDelayed(new Runnable() {
  16. @Override
  17. public void run() {
  18. ...
  19. }
  20. }, 1000000);
  21. }
  22. }
复制代码

(1)外部类Activity中定义了一个非静态内部类Handler,非静态内部类默认持有对外部类的引用。如果外部Activity突然关闭了,但是MessageQueue中的消息还没处理完,那么Handler就会一直持有对外部Activty的引用,垃圾回收器无法回收Activity,从而导致内存泄漏。

(2) 如上代码,在postDelayed中,我们在参数中传入一个非静态内部类Runnable,这同样会造成内存泄漏,假如此时关闭了Activity,那么垃圾回收器在接下来的1000000ms内都无法回收Activity,造成内存泄漏。

解决方案:

(1) 将非静态内部类Handler和Runnable转为静态内部类,因为非静态内部类(匿名内部类)都会默认持有对外部类的强引用。

(2) 改成静态内部类后,对外部类的引用设为弱引用,因为在垃圾回收时,会自动将弱引用的对象回收。

避免内存泄漏的例子:

  1. public class HandlerActivity extends AppCompatActivity {
  2. private final MyHandler mHandler = new MyHandler(this);
  3. private static final Runnable mRunnable = new Runnable() {
  4. @Override
  5. public void run() {
  6. // 操作
  7. }
  8. };
  9. @Override
  10. protected void onCreate(Bundle savedInstanceState) {
  11. super.onCreate(savedInstanceState);
  12. setContentView(R.layout.activity_fourth);
  13. mHandler.postDelayed(mRunnable, 1000*10);
  14. finish();
  15. }
  16. private static class MyHandler extends Handler {
  17. WeakReference<HandlerActivity> mWeakActivity;
  18. public MyHandler(HandlerActivity activity) {
  19. this.mWeakActivity = new WeakReference<HandlerActivity>(activity);
  20. }
  21. @Override
  22. public void handleMessage(Message msg) {
  23. super.handleMessage(msg);
  24. final HandlerActivity mActivity = mWeakActivity.get();
  25. if (mActivity != null) {
  26. // 处理消息
  27. }
  28. }
  29. }
  30. }
复制代码
HandlerThread

思考一下,假如我们需要同时下载A和B,下载A需要6s,下载B需要5s,在它们下载完成后Toast信息出来即可,此时HandlerThread便是一种解决方式之一。那么HandlerThread到底是什么?

  • HandlerThread就是一种线程。
  • HandlerThread和普通的Thread之间的区别就是HandlerThread在创建的时候会提供自己该线程的Looper对象。

所以,如果大家了解清楚了我前面所讲的Looper、Message、Handler、MessageQueue的关系的话,这里就很清楚HandlerThread是什么东西了。大家都知道,我们在Actvity创建时系统会自动帮我们初始化好主线程的Looper,然后这个Looper就会管理主线程的消息队列。但是在我们创建子线程时,系统并不会帮我们创建子线程的Looper,需要我们自己手动创建,如下:

  1. new Thread(){
  2. @Override
  3. public void run() {
  4. super.run();
  5. Looper.prepare();
  6. Handler mHandler = new Handler(Looper.myLooper());
  7. Looper.loop();
  8. }
  9. }.start();
复制代码

所以HandlerThread就在内部帮我们封装了Looper的创建过程,从源码可以看到,HandlerThread集成于Thread,然后覆写run方法,进行Looper的创建,从而通过getLooper方法暴露出该线程的Looper对象

  1. public class HandlerThread extends Thread {
  2. int mPriority;
  3. int mTid = -1;
  4. Looper mLooper;
  5. ...
  6. @Override
  7. public void run() {
  8. mTid = Process.myTid();
  9. Looper.prepare();
  10. synchronized (this) {
  11. mLooper = Looper.myLooper();
  12. notifyAll();
  13. }
  14. Process.setThreadPriority(mPriority);
  15. onLooperPrepared();
  16. Looper.loop();
  17. mTid = -1;
  18. }
  19. public Looper getLooper() {
  20. if (!isAlive()) {
  21. return null;
  22. }
  23. // If the thread has been started, wait until the looper has been created.
  24. synchronized (this) {
  25. while (isAlive() && mLooper == null) {
  26. try {
  27. wait();
  28. } catch (InterruptedException e) {
  29. }
  30. }
  31. }
  32. return mLooper;
  33. }
  34. ...
  35. }
复制代码

所以通过HandlerThread,我们可以轻松创建一个包含了Looper的子线程:

  1. final HandlerThread mHandlerThread = new HandlerThread("HandlerThread");
  2. mHandlerThread.start();
  3. Handler mHandler = new Handler(mHandlerThread.getLooper());
复制代码

使用HandlerThread同时下载A和B的Demo:

image

代码:

  1. public class HandlerThreadActivity extends AppCompatActivity {
  2. private TextView tv_A, tv_B;
  3. @Override
  4. protected void onCreate(Bundle savedInstanceState) {
  5. super.onCreate(savedInstanceState);
  6. setContentView(R.layout.activity_handler_thread);
  7. tv_A = (TextView) findViewById(R.id.txt_dlA);
  8. tv_B = (TextView) findViewById(R.id.txt_dlB);
  9. final Handler mainHandler = new Handler();
  10. final HandlerThread downloadAThread = new HandlerThread("downloadAThread");
  11. downloadAThread.start();
  12. Handler downloadAHandler = new Handler(downloadAThread.getLooper());
  13. // 通过postDelayed模拟耗时操作
  14. downloadAHandler.postDelayed(new Runnable() {
  15. @Override
  16. public void run() {
  17. Toast.makeText(getApplicationContext(), "下载A完成", Toast.LENGTH_SHORT).show();
  18. mainHandler.post(new Runnable() {
  19. @Override
  20. public void run() {
  21. tv_A.setText("A任务已经下载完成");
  22. }
  23. });
  24. }
  25. }, 1000 * 5);
  26. final HandlerThread downloadBThread = new HandlerThread("downloadBThread");
  27. downloadBThread.start();
  28. Handler downloadBHandler = new Handler(downloadBThread.getLooper());
  29. // 通过postDelayed模拟耗时操作
  30. downloadBHandler.postDelayed(new Runnable() {
  31. @Override
  32. public void run() {
  33. Toast.makeText(getApplicationContext(), "下载B完成", Toast.LENGTH_SHORT).show();
  34. mainHandler.post(new Runnable() {
  35. @Override
  36. public void run() {
  37. tv_B.setText("B任务已经下载完成");
  38. }
  39. });
  40. }
  41. }, 1000 * 7);
  42. }
  43. }
复制代码
总结

由于Android的UI更新只能在主线程,所以Handler是Android中一套非常重要的更新UI线程机制,虽然在很多框架的帮助下我们可以减少了很多Handler的代码编写,但实际上很多框架的底层实现都是通过Handler来更新UI的,所以可见掌握好Handler对我们来说是多么重要,所以这也是很多面试官在面试中的高频考点之一。虽然Handler对开发者来说是一个非常方便的存在,但是我们也不能否认它也是存在缺点的,如处理不当,Handler所造成的的内存泄漏对开发者来说也是一个非常头疼的难题。



回复

使用道具 举报