【Android】Handler 机制 ( Handler | Message | Looper | MessageQueue )（一）

I . Handler 机制简介

Handler 机制是 Android 中最重要的 异步通信 机制 ;

1 . Handler 机制作用 : 将需要执行的任务分配给其它线程 ;

① 子线程更新 UI : 在子线程中更新 UI , 就是在子线程中将刷新 UI 的任务分配给了主线程 ; ( 子线程刷新 UI 会崩溃 )

② 主线程网络操作 : 在主线程中 , 将网络通信等耗时的操作分配给子线程 ( 该子线程需要转成 Looper 线程 ) , 避免 UI 卡顿 ; ( 主线程访问网络会崩溃 )

2 . Handler 机制中涉及到的组件 :

① Handler ( 消息处理者 ) : 定义具体的代码操作逻辑 , 处理收到消息 ( Message ) 后的具体操作 ;

② Message ( 消息 ) : 定义具体消息 , 其中可以封装不同的变量 , 为 Handler 指定操作的类型 , 或执行操作所需的数据 ;

③ Looper ( 消息遍历者 ) : 消息的遍历者 , 遍历 MessageQueue 中的消息 , 分发给 Handler 处理 ;

④ MessageQueue ( 消息队列 ) : 封装在 Looper 中 , 每个 Looper 中封装了一个 MessageQueue , 是 Looper 消息遍历的重要组件 , 用户不直接调用该组件 ;

3 . Handler 机制中的 封闭性 与 线程交互 :

① 线程内部相对封闭的运行系统 : 整个 Looper 线程内部是一个封闭运行的系统 , Looper 一直不停的再遍历 MessageQueue , 将 消息 或 操作 取出 , 交给 Handler 执行 ;

② 线程交互 : Handler 还有另外一个职责就是负责与外部线程的交互 , 在外部线程中调用 Handler 将消息回传给本 Looper 线程 , 放入 MessageQueue 队列中 ;

4 . Message ( 消息 ) 的运行路径 ( 重点 ) : 在外部线程中 , 调用 Looper 线程的 Handler 成员 , 将 Message ( 消息 ) 发送给 Looper 线程中的 MessageQueue ( 消息队列 ) , 然后 Looper 轮询该 消息队列时 , 又将该消息交给 Handler 进行处理 ;

Message -> Handler ( 发送 ) -> MessageQueue ( 存储 ) -> Looper ( 轮询 ) -> Handler ( 执行 )

II . Handler 机制 Handler Message Looper MessageQueue 四组件对应关系

Handler , Message , Looper , MessageQueue 四组件对应关系 :

Handler 机制中的上述四者的对应关系 : 一个线程中只能有一个 Looper 及 Looper 中封装的 MessageQueue , 每个 Looper 可以为多个 Handler 调度消息 , Message 消息可以有无数个 ;

Looper 是 线程本地存储的对象 ( ThreadLocal ) , 一个线程只能存在一个 , MessageQueue ( 消息队列 ) 定义在 Looper 内部 , 每个 Looper 中只定义了一个 MessageQueue ( 消息队列 ) , 因此每个线程也只能有一个 MessageQueue ;

线程 与 Looper ( 消息遍历者 ) 是一对一关系 , Looper ( 消息遍历者 ) 与 MessageQueue ( 消息队列 ) 是一对一的关系 , Looper ( 消息遍历者 ) 与 Handler ( 消息处理者 ) 是一对多的关系 , Message ( 消息 ) 可以有很多 ;

III . Handler ( 消息处理者 )

1 . Handler 创建 : 这里注意 只能在 Looper 线程中创建 Handler , 普通线程不能创建 Handler ;

① 主线程 : 主线程中可以直接创建 Handler , 因为在点击应用图标后就会 启动主线程 ActivityThread , 此时就已经将 Looper 实例化好了 , 因此我们在 Activity 中 , 可以任意创建多个 Handler , 并直接使用 ;

public final class ActivityThread {
  ...
    public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();
  //创建 ActivityThread 线程, 并运行
        ActivityThread thread = new ActivityThread();
        //attach 方法 进行 thread 的最初初始化操作 
        thread.attach(false);
        ...
        Looper.loop();
        ...
    }//main
    ...
}//ActivityThread

② 子线程 : 子线程如果要创建 Handler , 需要先 调用 Looper.prepare() 方法 , 将线程转为 Looper 线程 , 因为 创建 Handler 时 , 会关联线程的 Looper 对象 , 普通的子线程是没有 Looper 对象的 , 调用 Looper.prepare() 方法即可为该线程创建 Looper 对象 , 该线程也就转为了 Looper 线程 ;

public class handler {
  ...
  //获取 Looper 对象后 , 可以从 Looper 对象中获取 MessageQueue
  //关联后 , Handler 发送消息时 , 才能将消息精准的发送给
  final MessageQueue mQueue;
  //Handler 需要与线程的唯一 Looper 对象关联
    final Looper mLooper;  
    ...
    public Handler() {
      ...
  mLooper = Looper.myLooper()
  if (mLooper == null) {
    throw new RuntimeException(
    "Can't create handler inside thread that has not called Looper.prepare()");
  }
  ...
  mQueue = mLooper.mQueue;
  ...
  }
  ...
}

2 . Handler 对象个数 : 每个 Looper 线程可以创建多个 Handler , 只要该 Handler 与 Looper 和 MessageQueue 关联 , 就可以将 消息 ( Message ) 发送给 Looper 线程中的 MessageQueue 中 ; Looper 轮询该 消息队列 ( MessageQueue ) , 将消息再次分发给对应的 Handler 进行处理 ;

IV . Looper ( 消息遍历者 )

1 . Looper 线程 : 如果要将 Handler , Looper 机制引入到线程中 , 使某线程具有接收 Message ( 消息 ) , 执行某项操作的功能 , 需要将该线程转为 Looper 线程 ;

2 . Looper 线程可执行的操作 : 一个线程如果被转为 Looper 线程 , 那这个线程运行后只能接收 Message 消息 , 执行对应的操作 , 运行后永远卡在 loop 循环遍历的 while (true) 循环中 , 使用 quit() 方法才能退出 ;

3 . Loop.prepare() 方法 : 该方法是将 普通子线程 转为 Looper 线程最终要的方法 , 该方法的主要作用是 创建 Looper , 然后将 Looper 对象放入 ThreadLocal 对象中存储 ; 线程只有创建了 Looper 对象才能创建 Handler , 将该 Looper 对象及其中封装的 MessageQueue 与 Handler 进行关联 , Handler 才可以进行消息的调度 ; 如果线程中没有 Looper 对象 , 创建 Handler 会报运行时异常 ;

public final class Looper {
  ...
  // sThreadLocal.get() will return null unless you've called prepare().
    @UnsupportedAppUsage
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
  ...
  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));
  }
  ...
}

4 . Loop.loop() 方法 : 一旦调用了该方法 , 就意味着该 Looper 线程进入到了轮询 MessageQueue 的阶段 , 这是一个无限死循环 , 调用了该方法后 , Handler 发送消息 , 线程才能处理对应的业务逻辑 ;

调用 quit() 方法 , 可以终止该遍历 MessageQueue 操作 ;

下面代码删除了大部分代码 , 只留下 循环遍历 和 调度 Message 信息给 Handler 进行处理 ;

public static void loop() {
    final Looper me = myLooper();
    ...
    final MessageQueue queue = me.mQueue;
    ...
    for (;;) {
        Message msg = queue.next(); // 阻塞
        if (msg == null) {
            // 循环遍历退出
            return;
        }
        ...
        try {
          //调度 Message 信息给 Handler 进行处理 
            msg.target.dispatchMessage(msg);
            ...
        } 
        ...
    }
}