关于android:Android入门教程-HandlerLooper与MessageQueue使用与分析

从源码角度剖析Handler。有利于应用 Handler 和剖析 Handler 的相干问题。意识Looper与Handler的关系。

Handler 简介

一个 Handler 容许发送和解决 Message，通过关联线程的 MessageQueue 执行 Runnable 对象。
每个 Handler 实例都和一个独自的线程及其音讯队列绑定。能够将一个工作切换到 Handler 所在的线程中去执行。一个用法就是子线程通过 Handler 更新 UI。

Handler次要有2种用法：

做出打算，在将来某个工夫点执行音讯和Runnable
线程调度，在其余线程布局并执行工作

要应用好 Handler，须要理解与其相干的 MessageQueue， Message和Looper；不能孤立的看Handler。 Handler就像一个操作者（或者像一个对开发者凋谢的窗口），利用MessageQueue和Looper来实现任务调度和解决。

Handler持有 Looper 的实例，间接持有looper的音讯队列。

属性与结构器

Handler 类中持有的实例，持有 looper，messageQueue 等等。

final Looper mLooper; // Handler持有Looper实例
final MessageQueue mQueue; // Handler持有音讯队列
final Callback mCallback;

在 Handler 的结构器中，咱们能够看到 Handler 获取了 Looper 的音讯队列。

public Handler(Callback callback, boolean async) {
    // rustfisher 解决异样
    mLooper = Looper.myLooper();
    // rustfisher 解决非凡状况...
    mQueue = mLooper.mQueue; // 获取的是Looper的音讯队列
}

public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue; // 获取的是Looper的音讯队列
    mCallback = callback;
    mAsynchronous = async;
}` </pre>

Handler 应用办法

Handler 发送和解决音讯的几个办法

void handleMessage( Message msg): 解决音讯的办法，该办法通常被重写。
final boolean hasMessage(int what): 查看音讯队列中是否蕴含有what属性为指定值的音讯
final boolean hasMessage(int what ,Object object) : 查看音讯队列中是否蕴含有what好object属性指定值的音讯
sendEmptyMessage(int what): 发送空音讯
final Boolean send EmptyMessageDelayed(int what ,long delayMillis): 指定多少毫秒发送空音讯
final boolean sendMessage(Message msg): 立刻发送音讯
final boolean sendMessageDelayed(Message msg,long delayMillis): 多少秒之后发送音讯

Handler.sendEmptyMessage(int what) 流程解析

获取一个Message 实例，并立刻将 Message 实例增加到音讯队列中去。
简要流程如下：

// 立即发送一个empty音讯
sendEmptyMessage(int what) 

// 发送提早为0的empty音讯  这个办法里通过Message.obtain()获取一个Message实例
sendEmptyMessageDelayed(what, 0) 

// 计算音讯的打算执行工夫，进入下一阶段
sendMessageDelayed(Message msg, long delayMillis)

// 在这里判断队列是否为null  若为null则间接返回false
sendMessageAtTime(Message msg, long uptimeMillis)

// 将音讯增加到队列中
enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)

// 接下来是MessageQueue增加音讯
// MessageQueue.java
boolean enqueueMessage(Message msg, long when)

能够看到，最初是把message增加到了messageQueue中。

Handler 勾销工作

要勾销工作时，调用上面这个办法removeCallbacksAndMessages(Object token)

public final void removeCallbacksAndMessages(Object token) {
    mQueue.removeCallbacksAndMessages(this, token);
}

通过调用 Message.recycleUnchecked() 办法，勾销掉与此 Handler 相关联的Message。

相干的音讯队列会执行勾销指令

void removeCallbacksAndMessages(Handler h, Object object)

音讯驱动与 Handler

Android是音讯驱动的，实现音讯驱动有几个因素

音讯的示意：Message
音讯队列：MessageQueue
音讯循环，用于循环取出音讯进行解决：Looper
音讯解决，音讯循环从音讯队列中取出音讯后要对音讯进行解决：Handler

初始化音讯队列

在Looper结构器中即创立了一个MessageQueue，Looper持有音讯队列的实例。

发送音讯

通过 Looper.prepare 初始化好消息队列后就能够调用 Looper.loop 进入音讯循环了，而后咱们就能够向音讯队列发送音讯，音讯循环就会取出音讯进行解决，在看音讯解决之前，先看一下音讯是怎么被增加到音讯队列的。

音讯循环

Java 层的音讯都保留在了 Java 层 MessageQueue 的成员 mMessages 中，Native 层的音讯都保留在了 Native Looper 的 mMessageEnvelopes 中，这就能够说有两个音讯队列，而且都是按工夫排列的。

Message 和 MessageQueue

与 Handler 工作的几个组件 Looper、MessageQueue 各自的作用：

Handler：它把音讯发送给 Looper 治理的 MessageQueue ,并负责解决Looper分给它的音讯
MessageQueue：治理 Message，由 Looper 治理
Looper：每个线程只有一个Looper，比方UI线程中，零碎会默认的初始化一个Looper对象，它负责管理 MessageQueue，一直的从MessageQueue中取音讯，并将绝对应的音讯分给Handler解决。

Message

Message 属于被传递，被应用的角色。Message 是蕴含形容和任意数据对象的“音讯”，能被发送给 Handler。Message 蕴含 2 个 int 属性和一个额定的对象。尽管结构器是公开的，但获取实例最好的方法是调用Message.obtain()或Handler.obtainMessage()。这样能够从他们的可回收对象池中获取到音讯实例。一般来说，每个Message实例持有一个Handler。

Message局部属性值

/*package*/ Handler target; // 指定的Handler

/*package*/ Runnable callback;

// 能够组成链表
// sometimes we store linked lists of these things
/*package*/ Message next;

从这里也不难看出，每个 Message 都持有 Handler 实例。如果 Handler 持有Activity的援用，Activity onDestroy 后 Message 却依然在队列中，因为 Handler 与Activity的强关联，会造成 Activity 无奈被 GC 回收，导致内存泄露。
因而在Activity onDestroy 时，与Activity关联的Handler应革除它的队列由Activity产生的工作，防止内存泄露。

重置本身的办法，将属性全副重置

public void recycle()
void recycleUnchecked()

获取 Message 实例的罕用办法，失去的实例与传入的 Handler 绑定

/**
 * Same as {@link #obtain()}, but sets the value for the <em>target</em> member on the Message returned.
 * @param h  Handler to assign to the returned Message object's <em>target</em> member.
 * @return A Message object from the global pool.
 */
public static Message obtain(Handler h) {
    Message m = obtain();
    m.target = h;

    return m;
}

将音讯发送给 Handler

/**
 * Sends this Message to the Handler specified by {@link #getTarget}.
 * Throws a null pointer exception if this field has not been set.
 */
public void sendToTarget() {
    target.sendMessage(this); // target 就是与音讯绑定的Handler
}

调用这个办法后，Handler 会将音讯增加进它的音讯队列MessageQueue中。

MessageQueue

持有一列能够被 Looper 散发的 Message。一般来说由 Handler 将 Message 增加到 MessageQueue 中。获取以后线程的 MessageQueue 办法是Looper.myQueue()。通过 Looper.getMainLooper() 获取到主线程的 looper。

Looper 简介

Looper 与 MessageQueue 严密关联。在一个线程中运行的音讯循环。线程默认状况下是没有与之治理的音讯循环的。
要创立一个音讯循环，在线程中调用 prepare，而后调用 loop。即开始解决音讯，直到循环进行。大多数状况下通过Handler来与音讯循环互动。

Handler 与 Looper 在线程中交互的典型例子

class LooperThread extends Thread {
    public Handler mHandler;
    public void run() {
        Looper.prepare(); // 为以后线程筹备一个Looper
        // 创立Handler实例，Handler会获取以后线程的Looper
        // 如果实例化Handler时以后线程没有Looper，会报异样 RuntimeException
        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };
        Looper.loop(); // Looper开始运行
    }
}

调用了 Looper.loop() 之后，looper 开始运行。当 looper 的 messageQueue 中没有音讯时，相干的线程处于什么状态呢？查看looper的源码，看到loop办法外面有一个死循环。queue.next()办法是可能会阻塞线程的。如果从queue中获取到null，则表明此音讯队列正在退出。此时looper的死循环也会被返回。

for (;;) {
    Message msg = queue.next(); // might block
    if (msg == null) {
        // No message indicates that the message queue is quitting.
        return;
    }

调用 looper 的 quit 办法，实际上调用了 mQueue.quit(false)。音讯队列退出后，looper 的 loop 死循环也被退出了。

进入 MessageQueue 的next办法去看，发现外面也有一个死循环。没有音讯时，这个死循环会阻塞在nativePollOnce这个办法。

Message next() {
    // ...
    for (;;) {
        // ...
        nativePollOnce(ptr, nextPollTimeoutMillis);
        // 解决message对象

咱们晓得 Thread 有 New（新建，未运行），RUNNABLE（可运行），BLOCKED，WAITING（线程领有了某个锁之后, 调用了他的wait办法, 期待其余线程/锁拥有者调用 notify / notifyAll），TIMED_WAITING，TERMINATED（曾经执行结束）这几种状态。

音讯队列中没有音讯，在nativePollOnce办法中“期待”。nativePollOnce成果上大抵等同于Object.wait()，但它们的实现齐全不同。nativePollOnce应用 epoll, 而 Object.wait 应用 futex。

“期待”时，相干线程则处于WAITING状态。

Looper中的属性

Looper 持有 MessageQueue；惟一的主线程 Looper sMainLooper；Looper 以后线程 mThread；存储 Looper 的 sThreadLocal

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper;  // guarded by Looper.class

final MessageQueue mQueue; // Handler会获取这个音讯队列实例（参考Handler结构器）
final Thread mThread; // Looper以后线程

ThreadLocal并不是线程，它的作用是能够在每个线程中存储数据。

Looper办法

筹备办法，将以后线程初始化为 Looper。退出时要调用 quit

public static void prepare() {
    prepare(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)); // Looper实例存入了sThreadLocal
}

prepare办法新建 Looper 并存入 sThreadLocal sThreadLocal.set(new Looper(quitAllowed))

ThreadLocal<T>类

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

当要获取 Looper 对象时，从 sThreadLocal 获取

// 获取与以后线程关联的Looper，返回能够为null
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

在以后线程运行一个音讯队列。完结后要调用退出办法quit()

public static void loop()

筹备主线程 Looper。Android 环境会创立主线程 Looper，开发者不应该本人调用这个办法。
UI线程，它就是 ActivityThread，ActivityThread 被创立时就会初始化 Looper，这也是在主线程中默认能够应用 Handler 的起因。

public static void prepareMainLooper() {
    prepare(false); // 这里示意了主线程Looper不能由开发者来退出
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

获取主线程的 Looper。咱们开发者想操作主线程时，可调用此办法

public static Looper getMainLooper()

同一个 Thread 的不同 Handler

与 UI 线程对应的 MainLooper，能够关联多个 Handler。多个 Handler 之间的打算工作不会相互影响。比方有 2 个关联了 UI 线程的 handler。

Handler mMainHandler1;
Handler mMainHandler2;

private void initUtils() {
    mMainHandler1 = new Handler(Looper.getMainLooper());
    mMainHandler2 = new Handler(Looper.getMainLooper());
    Log.d(TAG, "mMainHandler1 post 工作");
    mMainHandler1.postDelayed(new Runnable() {
        @Override
        public void run() {
            Log.d(TAG, "mMainHandler1的演示工作已执行 rustfisher");
        }
    }, 1500);
    mMainHandler2.removeCallbacksAndMessages(null);
}

mMainHandler2 勾销它的工作并不会影响 mMainHandler1。

Handler 相干面试题

1. ⼦线程⼀定不能更新 UI 吗？

答：不⼀定。

Activity存在⼀种审计机制，这个机制会在Activity齐全显示之后⼯作，如果⼦线程在Activity齐全显示
之前更新UI是可⾏的；
SurfaceView：多媒体视频播放，也能够在⼦线程中更新UI
Progress：进度相干控件，也能够在⼦线程中更新UI

2. 给我说说 Handler 的原理

3. Handler 导致的内存泄露你是如何解决的？

4. 如何使⽤Handler让⼦线程和⼦线程通信？

发送音讯的⼦线程

  package com.cdc.handler;
  import android.os.Handler;
  import android.os.Message;
  import android.os.SystemClock;
  //发送音讯的⼦线程
  public class Thread1 extends Thread {
       private Handler handler;
       public Thread1(Handler handler){
           super.setName("Thread1");
           this.handler=handler;
       }
       @Override
       public void run() {
           Message msg = Message.obtain();
           msg.what = 1;
           msg.obj = System.currentTimeMillis()+"";
           handler.sendMessage(msg);
           System.out.println((Thread.currentThread().getName() + "----发送了消
息！" + msg.obj));
          SystemClock.sleep(1000);
  }
}

接管音讯的⼦线程

  package com.cdc.handler;
  import android.os.Handler;
  import android.os.Looper;
  //接管音讯的⼦线程
  public class Thread2 extends Thread{
      private Handler handler2;
      public Handler getHandler(){//留神哦，在run执⾏之前，返回的是null
          return handler2;
      }
      public Thread2(){
          super.setName("Thread2");
      }
      @Override
      public void run() {
          //在⼦线程⾥⾯新建Handler的实例，须要先调⽤Looper.prepare();否则会报
错:Can't create handler inside thread that has not called Looper.prepare()
          Looper.prepare();
          handler2 = new Handler(){
              public void handleMessage(android.os.Message msg) {
              //这⾥解决音讯
              System.out.println(("收到音讯了：" +
Thread.currentThread().getName() + "----" + msg.obj));
          };
      };
      Looper.loop();
  }
}

调⽤

private Handler myHandler=null;
private Thread2 thread1;
private Thread1 thread2;
@OnClick(R.id.handler3)
public void handler3(){
  thread1=new Thread2();
  thread1.start();
  myHandler=thread1.getHandler();
  while(myHandler==null){
      SystemClock.sleep(100);
      myHandler=thread1.getHandler();
  }
  thread2=new Thread1(myHandler);
  thread2.start();
}

5. HandlerThread是什么 & 原理 & 使⽤场景？

6. IdleHandler是什么？

7. ⼀个线程是否创立多个Handler,Handler和Looper之间的对应关系？

8 为什么Android零碎不倡议⼦线程拜访UI？
⾸先，UI控件不是线程平安的，如果多线程并发拜访UI控件可能会呈现不可预期的状态
那为什么零碎不对UI控件的拜访加上锁机制呢？毛病有两个：

加上锁机制会让UI拜访的逻辑变得复杂；
锁机制会升高UI拜访的效率，因为锁机制会阻塞某些线程的执⾏

鉴于这两个毛病，最简略且⾼效的⽅法就是采⽤单线程模型来解决UI操作，所以源码ViewRootImpl中会有对线程的⼀个判断，代码如下： frameworks/base/core/java/android/view/ViewRootImpl.java

void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can
touch its views.");
     }
 }

对于开发者来说也不是很麻烦，只是通过 handler 切换⼀下 UI 拜访的执⾏线程即可

9. Looper 死循环为什么不会导致应⽤卡死？

10. 使⽤ Handler 的 postDealy 后音讯队列有什么变动？

Android零根底入门教程视频参考

关于android:Android入门教程-HandlerLooper与MessageQueue使用与分析

Handler 简介

属性与结构器

Handler 应用办法

音讯驱动与 Handler

Message 和 MessageQueue

Message

MessageQueue

Looper 简介

Looper中的属性

Looper办法

同一个 Thread 的不同 Handler

Handler 相干面试题

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于android:Android入门教程-HandlerLooper与MessageQueue使用与分析

Handler 简介

属性与结构器

Handler 应用办法

音讯驱动与 Handler

Message 和 MessageQueue

Message

MessageQueue

Looper 简介

Looper中的属性

Looper办法

同一个 Thread 的不同 Handler

Handler 相干面试题

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复