关于Android那些事--handler

简述

Handler 与 Message、MessageQueue、Looper 一起构成了 Android 的消息机制，主要用来进行线程间通信来达到与用户进行交互，View 的绘制、点击事件、Activity 的生命周期回调等作用。

Handler：Handler 负责发送和处理 Message；创建时先获取默认或传递来的 Looper 对象，并持有 Looper 对象包含的 MessageQueue，发送消息时使用该 MessageQueue 对象来插入消息并把自己封装到具体的 Message 中。
Message：消息，负责传递标示(what) 和数据(obj) ；每个 Message 都会通过 target 这个成员变量来绑定一个 Handler，由这个 Handler 来发送和处理 Message。
MessageQueue：消息队列，负责存放有 Handler 发送过来的消息；每个 Handler 中都有一个 final类型的MessageQueu，Handler 发送消息就是把消息加入这个 MessageQueue 。
Looper：负责不断的从 MessageQueue 中取出消息然后交给 Handler（Message#target ）处理；每个 Looper 中都有一个唯一的消息队列（MessageQueue），每个 Handler 中都有一个 final类型的Looper来进行消息的无限循环，Handler 中的 MessageQueue 就是来自 Looper。如果获取的 MessageQueue 没有消息时，便阻塞在 loop 的queue.next() 中的 nativePollOnce() 方法里，反之则唤醒主线程继续工作，之后便使用 Message 封装的 handler 对象进行处理

注意：每个线程只能有一个 Looper 和一个 MessageQueue，可以有多个 Handler，每个 Handler 可以发送和处理多个 Message。

注意事项

使用Handler时可能引起内存泄漏
- Java 中非静态内部类和匿名内部类会持有外部类的引用
  - 非静态的内部 Handler 子类、匿名 Handler 子类会持有外部类的引用(Activity)，而 Handler 可能会因为要等待处理耗时操作导致存活时间超过 Activity，或者消息队列中存在未被 Looper 处理的 Message ，而 Message 会持有 Handler 的引用。于是，在 Activity 退出时，其引用还是被 Handler 持有，导致 Activity 无法被及时回收，造成内存泄露。
- Handler 的生命周期比外部类长
  - 非静态的内部 Runnable 子类、匿名 Runnable 子类 post 到任意 Handler 上时，Runnable 其实是 Massage中的 Callback，持有 Message 引用，如果这个 Massage 在消息队列还没有被处理，那么就会造成 Runnable 一直持有外部类的引用而造成内存泄露。
解决方案
- 根本思路：让使用handler的对象在自己生命周期内使用handler，不使用及时移除Messages
- 通过静态内部类或者外部类来声明 Handler 和 Runnable。
- 通过弱引用来拿到外部类的变量。
- 在 Activity/Fragment 销毁的时候请空 MessageQueue 中的消息。

源码分析

在主线程的入口，ActivityThread 的 main 方法

public static void main(String[] args) {
        // 准备主线程的 Looper     
        Looper.prepareMainLooper();
        // 创建 ActivityThread
        ActivityThread thread = new ActivityThread();
        // 用于绑定应用进程
        thread.attach(false);
        // 获取主线程的 Handler 
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
  
        // 对消息队列进行无线轮询，处理消息
        Looper.loop();
        // 一旦跳出循环，抛出异常（Android 不允许跳出主线程的 Looper.loop()）
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

逐步分析
==> Looper.prepareMainLooper()

public static void prepareMainLooper() {
     // 准备一个 Looper, false 不允许退出
     prepare(false);
     synchronized (Looper.class) {
         // main Looper 只能初始化一次，再次初始化会抛出异常
         if (sMainLooper != null) {
             throw new IllegalStateException("The main Looper has already been prepared.");
         }
         // 获取 main Looper
         sMainLooper = myLooper();
     }
 }

==> prepare(false)

// 准备一个 Looper，quitAllowed 是否允许 Looper 中的 MessageQueue 退出
// 默认 prepare() 允许退出，主线程这里不允许退出
private static void prepare(boolean quitAllowed) {
 // 先看下 sThreadLocal 是什么
 // static final ThreadLocal sThreadLocal = new ThreadLocal();
 // ThreadLocal:线程本地存储区，每个线程都有本地存储区域，这个区域是每个线程私有的，不同的线程不能之间不能彼此访问
 // 如果 sThreadLocal 中有数据，抛出异常，换句话说 prepare() 这个函数每个线程只能执行一次
 if (sThreadLocal.get() != null) {
     throw new RuntimeException("Only one Looper may be created per thread");
 }
 // 创建 Looper 保存到该线程的 ThreadLocal 中
 sThreadLocal.set(new Looper(quitAllowed));
}

总结：用 ThreadLocal 来保存该线程的 Looper 对象。ThreadLocal 可以看作是一个用来储存数据的类，类似 HashMap、ArrayList等集合类，它存放着属于当前线程的变量。

==> new Looper(quitAllowed)

private Looper(boolean quitAllowed) {
 // 在 Looper 创建的时候创建一个消息队列
 // quitAllowed:消息队列是否可以退出，主线的消息队列肯定不允许退出，所以上面是 prepare(false)
 // quitAllowed 为 false 执行 MessageQueue#quit 退出消息队列时会出现异常
 mQueue = new MessageQueue(quitAllowed);
 // 获取 Looper 存在于哪个线程
 mThread = Thread.currentThread();
}

==> sMainLooper = myLooper()

public static @Nullable Looper myLooper() {
 // 从 sThreadLocal 中获取当前线程的 Looper 
 // 如果当前线程没有调用 Looper.prepare 返回 null， 无准备无对象
 return sThreadLocal.get();
}

==> sMainThreadHandler = thread.getHandler();

final Handler getHandler() {
 // 返回 mH
 return mH;
}

// mH 在成员变量的位置 new H()
final H mH = new H();

// H 继承了 Handler 封装了一系列关于 Acitivty、Service 以及其他 Android 相关的操作
private class H extends Handler

总结：在主线程的 main 方法中，会创建主线程的 Looper、MessageQueue，然后进入 Looper.loop() 循环中，不断的取出消息，处理消息，以此来驱动 Android 应用的运行。

2、Handler 的创建，Handler 的所有构造方法都会跳转到下面两个之一

public Handler(Callback callback, boolean async) {
 // Hanlder 是匿名类、内部类、本地类时，如果没有声明为 static 则会出现内存泄漏的警告
 if (FIND_POTENTIAL_LEAKS) {
     final Class 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()");
 }
 // 消息队列，从 Looper 中获取
 mQueue = mLooper.mQueue;
 // 处理消息的回调接口
 mCallback = callback;
 // 处理消息的方式是否为异步，默认同步
 mAsynchronous = async;
}

public Handler(Looper looper, Callback callback, boolean async) {
 mLooper = looper;
 mQueue = looper.mQueue;
 mCallback = callback;
 mAsynchronous = async;
}

总结：
在 Handler 的构造方法中，Handler 和 Looper、MessageQueue 绑定起来，如果当前线程没有 Looper 抛出异常(这也是为什么直接在子线程创建 Handler 会出现异常)。
故：

说明了Handler 必须在有 Looper 的线程中使用。
Handler 的 MessageQueue 对象是由当前线程 Looper 的 MessageQueue 对象赋值的。
Handler 在创建时绑定了当前线程 Looper 的 MessageQueue 对象。
对于传递 Looper 对象创建 Handler 的情况下，传递的 Looper 是哪个线程的，Handler 绑定的就是该线程。

3、使用 Handler 发送消息
==> sendMessageAtTime(Message msg, long uptimeMillis)

// 除了 sendMessageAtFrontOfQueue，Handler 所有的 post、sendMessage 都会跳到这个方法
// Message msg: 要发送的消息
// long uptimeMillis: 发送消息的绝对时间，通过 SystemClock.uptimeMillis() 加上我们自己的延迟时间 delayMillis 计算而来
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
  MessageQueue queue = mQueue;
  // 消息队列为空（可能已经退出）返回 false 入队失败
  if (queue == null) {
    RuntimeException e = new RuntimeException(
      this + " sendMessageAtTime() called with no mQueue");
    Log.w("Looper", e.getMessage(), e);
    return false;  
  }
  // 消息入队
  return enqueueMessage(queue, msg, uptimeMillis);
}

==> sendMessageAtFrontOfQueue(Message msg)

// 发送消息到 MessageQueeu 的队头
public final boolean sendMessageAtFrontOfQueue(Message msg) {
 MessageQueue queue = mQueue;
 if (queue == null) {
     RuntimeException e = new RuntimeException(
     this + " sendMessageAtTime() called with no mQueue");
     Log.w("Looper", e.getMessage(), e);
     return false;
 }
 // 通过设置 uptimeMillis 为 0，是消息加入到 MessageQueue 的队头
 return enqueueMessage(queue, msg, 0);
}

==> enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)

// 所有 Handler 的 post 、sendMessage 系列方法和 runOnUiThread 最终都会调用这个方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
 // msg.target 是一个 Handler，将 Message 和 Handler 绑定
 // 也就是用哪个 Handler 发送消息，这个 Message 就和哪个 Handler 绑定
 msg.target = this;
 // 如果设置了消息处理方式为异步处理
 if (mAsynchronous) {
     msg.setAsynchronous(true);
 }
 // MessageQueue 的方法，将消息入队
 return queue.enqueueMessage(msg, uptimeMillis);
}

-> MessageQueue#enqueueMessage(Message msg, long when)

boolean enqueueMessage(Message msg, long when) {
     // Messgae 没有绑定 Handler 抛出异常
     if (msg.target == null) {
         throw new IllegalArgumentException("Message must have a target.");
     }
     // Messgae 正在使用 抛出异常
     if (msg.isInUse()) {
         throw new IllegalStateException(msg + " This message is already in use.");
     }
 
     synchronized (this) {
         // 消息队列正在退出，回收 Message
         if (mQuitting) {
             IllegalStateException e = new IllegalStateException(
                     msg.target + " sending message to a Handler on a dead thread");
             Log.w(TAG, e.getMessage(), e);
             msg.recycle();  // 调用 Message#recycleUnchecked() 
             return false;
         }
         msg.markInUse();  // 标记 Message 正在使用
         msg.when = when;  // 设置 Message 的触发时间
       
         // mMessages 记录着 MessageQueue 的队头的消息 
         Message p = mMessages;  
         boolean needWake;
         // MessageQueue 没有消息、Message 触发时间为 0、Messgae 触发时间比队头 Message 早
         // 总之这个 Message 在 MessageQueue 中需要最先被分发
         if (p == null || when == 0 || when < p.when) {
             // New head, wake up the event queue if blocked.
             msg.next = p;     // 将以前的队头 Message 链接在这个 Message 后面
             mMessages = msg;  // 将这个 Message 赋值给 mMessages
             needWake = mBlocked;  // 队列是否阻塞
         } else {
             // 标记队列是否阻塞
             needWake = mBlocked && p.target == null && msg.isAsynchronous();
             Message prev;
           
             // 按照时间顺序将 Message 插入消息队列
             for (;;) {
                 prev = p;   // prev 记录队头
                 p = p.next; // p 记录队头的后一个
                 // 队头后面没有消息或者其触发事件比要插入的 Message 晚，跳出循环
                 if (p == null || when < p.when) {
                     break;
                 }
                 if (needWake && p.isAsynchronous()) {
                     needWake = false;
                 }
             }
             // 将 Message 插入队列
             msg.next = p; 
             prev.next = msg;
         }

         // We can assume mPtr != 0 because mQuitting is false.
         if (needWake) {
             nativeWake(mPtr);
         }
     }
     return true;
 }

总结：到现在为止，我们的 Handler 已经将 Message 发送到了 MessageQueue，Message 静静的等待被处理。

4、Looper.loop() 还记得这个方法在 ActivityThread 的 main 调用了吗？正是它在不断处理 MessageQueue 里面的消息。

public static void loop() {
     // 获取 Looper.Looper.prepare 准备好的 Looper
     final Looper me = myLooper();
     if (me == null) {
         throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
     }
     // 获取 Looper 中的消息队列
     final MessageQueue queue = me.mQueue;

     // 进入无线循环
     for (;;) {
         // 取出下一条消息
         Message msg = queue.next(); 
         
         // 没有消息，退出 loop
         // 其实上面 queue.next() 也是一个无限循环，获取到消息就返回，没有消息就一直循环
         if (msg == null) {
             return;
         }

         try {
             // msg.target 实际上就是一个 Handler
             // 获取到了消息，使用绑定的 Handler#dispatchMessage 分发消息
             msg.target.dispatchMessage(msg);
         } finally {
             
         }

         // 释放消息，把 Message 的各个变量清空然后放进消息池中
         msg.recycleUnchecked();
     }
 }

5、Handler#dispatchMessage(msg) 消息是如何处理的

public void dispatchMessage(Message msg) {
 // 调用 Handler 的 post 系列方法执行handleCallback(msg)
 if (msg.callback != null) {
     handleCallback(msg);
 } else {
     // 创建 Handler 传入 Callback
     if (mCallback != null) {
         if (mCallback.handleMessage(msg)) {
             return;
         }
     }
     // 3. 创建 Handler 时重写的 handleMessage
     handleMessage(msg);
 }
}

从这就可以看出消息分发的优先级：

Message 的回调方法：message.callback.run(); 优先级最高；
Handler 的回调方法：mCallback.handleMessage(msg)优先级次于上方；
Handler 的回调方法：handleMessage() 优先级最低。

Handler 机制总结：想使用 Handler 必须要有 Looper，创建 Looper 的时候会创建 MessageQueue，在 Handler 的构造的时候会绑定这个 Looper 和 MessageQueue，Handler 将 Message 发送到 MessageQueue 中，Looper.loop() 会不断的从 MessageQueue 取出消息再交给这个 Handler 处理。

关于Android那些事--handler

简述

注意事项

源码分析

你可能感兴趣的:(关于Android那些事--handler)