Handler 源码走一走，看一看-CSDN博客

本文链接：https://blog.csdn.net/jiaqiangziji/article/details/80097391

Handler 源码走一走，看一看 Handler 是如何发送和处理消息

文章将分为以下几步介绍 Handler

Handler 是做什么的？
为什么使用Handler?
Handler 是如何使用的？
Handler 通过new 创建以后都做了什么？
Handler 是如何发送和处理消息的
使用Handler 应该注意什么

Handler 是做什么的？

Handler 类的文档注释是这样形容的：
- Handler 允许程序用来发送和处理与 Runnable 和线程相关联的对象。每个Handler 都与单个线程和改线程的消息队列相关联，当你创建一个新的处理程序时，它将绑定到创建他的线程和线程消息队列，从那时候起，它将消息和可运行消息传递到该消息队列，并在消息出来时执行他们。
  一句话总结：Handler 是一个异步消息机制，用来执行子线程发送的消息在主线程做处理。

为什么要使用 Handler？

假设屏幕上有TextView 控件，我们需要开启线程请求数据并在数据回来以后跟新 TextView 文本（请求数据是耗时操作不可以在UI线程进行，否则会出现 ANR 程序无响应），我们在不使用Handler 情况下直接操作 TextView 看看会出现什么？

 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    mTips = findViewById(R.id.tv_tips);
    //开启线程模拟数据请求 并更新UI
   new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mTips.setText("Handler 消息机制");
        }
    }).start();

}
}

点击 run 运行项目，直接崩溃，通过查看控制台我们可以看到以下信息

 android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created 
 a view hierarchy can touch its views.
 at android.view.ViewRootImpl.checkThread(ViewRootImpl.java:6610)
    at android.view.ViewRootImpl.requestLayout(ViewRootImpl.java:936)
    at android.view.View.requestLayout(View.java:18761)
 ......

异常信息直接告诉了我们只能在创建这个控件的线程里面更新这个View，简介的说明我们可以发现视图的更新只能发生在UI 线程，而不可以在子线程更新控件，原因是在子线程更新控件是不安全的。
既然在子线程不能更新 UI ，那我们如何把消息发送到 UI 线程呢？Handler 这时候就派上了用场了。正如第一节所说Handler是异步消息机制，用来发送和处理消息的。

Handleer 如何使用

创建一个匿名的 Handler ,重写 handlerMessage()方法
Java private Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { super.handleMessage(msg); // 接受到消息并交给控件对消息做处理 mTips.setText((String) msg.obj); Log.d("MainActivity", "handleMessage: " + (String) msg.obj); } };

使用匿名创建的 Handler 对象来发送消息

 @Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    mTips = findViewById(R.id.tv_tips);
    //开启线程模拟数据请求 并更新UI
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Message obtain = Message.obtain();
            obtain.obj = "Handler 消息机制";
            mHandler.sendMessage(obtain);
        }
    }).start();

}

通过以上两步就把一个消息从子线程发送到了UI线程并做了处理。调用者如此简单，那么 Handler 类是如何做到呢？

Handler 是如何做到在异步发送消息到 UI 线程的呢？
- 在使用当中，我们首先 new Handle()，重写了 handleMessage();就这么简单我们就可以发送和接受消息了，既然这样 Handler 里面做了一些操作，才让调用者如此简单的使用，那么 Handler 如何做的呢？了解一个类就要从类的构造方法开始以及都有哪些方法？
```
/**
 * Default constructor associates this handler with the {@link Looper} for the
 * current thread.
 *
 * If this thread does not have a looper, this handler won't be able to receive messages
 * so an exception is thrown.
 */
public Handler() {
    this(null, false);
}
```
从上面可以看出无参构造调用了有两个参数的构造方法，第一个参数为 null,第二个参数为false，由此我们可以指直接看带两个参数的构造方法
```
    this(null,false)
 public Handler(Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
        final Class<? extends Handler> klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                (klass.getModifiers() & Modifier.STATIC) == 0) {

            Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                klass.getCanonicalName());
        }
    }
    // 获取Looper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}
```
```
    -
```
以上构造方法都做了哪些事情呢？
1. 通过 looper.myLooper 返回了一个Looper 对象。问题接着就来了，Looper 是啥呢？做什么的呢？只有进到 Looper类才能知道 looper是做什么的？`
  1. 首先 Looper 类的文档是如何对 Looper 描述的呢？
    Looper 是用于为线程运行消息循环的一个类。线程中默认是没有消息循环的，所以为了循环线程的消息需要创建一个 Looper，请在要运行该循环的线程中调用 Looper.prepare()，然后在调用 Looper.loop 让它来处理消息，直到循环停止。并且如何使用文档注释也给了用例
```
class LooperThread extends Thread {
                  public Handler mHandler;
                 public void run() {
                   Looper.prepare();
                   mHandler = new Handler() {
                      public void handleMessage(Message msg) {
                             // process incoming messages here
        }
  };
   Looper.loop();
}
```
  通过文档我们知道了 Looper是用来循环线程中的消息。但是运行该消息就必须要创建一个 Looper，通过 Looper.prepare()创建 Looper ，并调用 Looper.loop来处理的。接下来我们看看 Looper.prepare() 是如何创建 Looper的呢?
```
     /** Initialize the current thread as a looper.
* This gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. Be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
public static void prepare() {
prepare(true);
}
```
  从中可以看出 prepare() 方法是一个重载方法() ,它有调用了带有一个参数的 prepare() 方法。参数是一个Boolean 类型并且传值为 true。那么我们看看这个带参数的重载方法做了什么操作
```
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
    throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
```
  在prepare() 方法里面做了一件事就是：
  1. 通过变量 sthreadLocal.get() 来判断 Looper 是否存在，在抛出的异常里面可以看到每个线程只能创建一个Looper，也就是每次在获取的时候会对当前线程的Looper 做一个判断，如果当前已经有了那么就对调用者抛出异常。通过定位sThreadLocal 变量发现是在Looper 里面定义了一个 static final ThreadLocal sThreadLocal = new ThreadLocal(); 对象，至于 ThreadLoal 是做什么在此就不解释了。我们只要跟踪是如何获取到 Looper 对象的就可以了。通过 sThreadLocal.get() 方法返回了 Looper，如果返回的是null 那么就通过 sThreadLocal.set(new Looper(quitAllowed)) 来创建了一个 Looper，定位到 set()方法里面可以通过源码看到就是获取当前的线程的对象作为键存储在了 Map 集合里面。

总结：Looper 其实就是对当前线程的消息进行循环的，每一个线程只能对应一个Looper。通过 ThreadLocal 来获取和实例化 Looper的。

再次回到带有两个参数的 Handler 方法里面一步步走读 Handler 构造方法里面做了什么事？
1. 调用 Looper.myLooper() 通过 sThreadLocal.get() 来获取Looper，如果没有就返回null.
2. 判断在第一步里面获取的 Looper对象是否为null.如果获取的Loopr 是null 的话，就抛出不能再没有 Looper.prepare() 里面创建Handler。
3. 调用 mLooper.mQueue() 返回了一个 mQueue 变量，定位 mQueue 是在Handler 里面定义的一个 final MessageQueue 对象。那么 MessageQueue 对象是什么呢？为什么通过 Looper对象来获取的呢？
1. 定位到 MessageQueue 类里面看类的文档注释：MessageQueue 是一个低级别的类拥有分派消息的集合。消息不会直接添加到MessageQueue，而是通过与Looper关联的对象。也就是说 MessageQueue 和Looper 是有关联的。
2. 通过文档知道了 MessageQueue 是一个消息列表。而Handler 使用来发送消息的，由此可以知道Handler 发送的消息都发送到了 MessageQueue 对象里面。
既然知道了 MessageQueue 是和 Looper 有关联的，那么通过 mLooper.mQueue来获取也就一点都不奇怪了。但是Looper 又是如何实例化 MessageQueue 对象的呢。通过定位到 Looper 里面可以看出在 Looper 实例化的时候同时也实例化了 MessageQueue 对象。有此可以看出 Looper 和 MessageQueue 是相伴相生的。既然 MessageQueue 是存储消息的那就只能在Handler 发送消息的时候看如何把消息添加到消息队列的。
通过跟踪定位发现 Handler 做了一下事件：
1. 使用Handler 必须获取当前线程的Looper。通过 Looper.prepare().
2. 获取当前线程的 Looper，一个线程只能有一个Looper。
3. Looper 和 MessageQueue 是相伴相生的，一个 Looper 对应一个MessageQueue.
既然使用Handler 必须通过 Looper.prepare()方法获取，可是在示例中却没有调用 Looper.prepare()方法呢？并且也没有报出不能再没有 Looper.prepare() 里面创建Handler，既然没有抛出那就说明我们可以获取到当前UI线程的Looper。而当前线程的Looper 肯定是系统帮我们调用了实例化方法。

Handler 是如何发送和处理消息的

发送消息
- 在示例中通过 mHandler.sendMessage()我们发送了一个消息，我们定位到这个方法看看消息是如何发送到 MessageQueue 里面的呢？

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

通过最终定位都调用了 enqueueMessage() 方法：
1. msg.target = this; 给发送的消息做了一个标记，而这个标记引用的是当前Handler对象。
2. 由于在 Handler 里面 mAsynchronous 赋值为false，这句代码就暂时不管是做什么的了。
3. 返回了
未完待续。。。。

插入链接 Ctrl + L
- 插入代码 Ctrl + K
- 插入图片 Ctrl + G
- 提升标题 Ctrl + H
- 有序列表 Ctrl + O
- 无序列表 Ctrl + U
- 横线 Ctrl + R
- 撤销 Ctrl + Z
- 重做 Ctrl + Y

Markdown及扩展

Markdown 是一种轻量级标记语言，它允许人们使用易读易写的纯文本格式编写文档，然后转换成格式丰富的HTML页面。 —— [ 维基百科 ]

使用简单的符号标识不同的标题，将某些文字标记为粗体或者斜体，创建一个链接等，详细语法参考帮助？。

本编辑器支持 Markdown Extra , 　扩展了很多好用的功能。具体请参考Github.

表格

Markdown　Extra　表格语法：

项目	价格
Computer	$1600
Phone	$12
Pipe	$1

可以使用冒号来定义对齐方式：

项目	价格	数量
Computer	1600 元	5
Phone	12 元	12
Pipe	1 元	234

定义列表

Markdown　Extra　定义列表语法：项目１项目２

定义 A

定义 B

项目３

定义 C

定义 D

定义D内容

代码块

代码块语法遵循标准markdown代码，例如：

@requires_authorization
def somefunc(param1='', param2=0):
    '''A docstring'''
    if param1 > param2: # interesting
        print 'Greater'
    return (param2 - param1 + 1) or None
class SomeClass:
    pass
>>> message = '''interpreter
... prompt'''