Handler连环问能过几关#

1. 说说你理解的Handler#

handler代码主要在以下几个类

1
//\frameworks\base\core\java\android\os\Looper.java
2
//\frameworks\base\core\java\android\os\Message.java
3
//\frameworks\base\core\java\android\os\MessageQueue.java

1. Android Handler 是一套 异步消息传递机制（异步通信机制）。主要适用于同一个组件（或者说是同一个文件中）不同线程之间的信息传递。
2. 在子线程中进行耗时的 IO 操作，这可能是读取文件或者访问网络等，当耗时操作完成以后可能需要在 UI上做一些改变，由于 Android 开发规范的限制，我们并不能在子线程中访问 UI 控件，否则就会触发程序异常，这个时候通过 Handler 就可以将更新 UI 的操作切换到主线程中执行。
3. Handler机制 由Handler，Message，MessageQueue和Looper四个组件组成

其中

• Message 是线程之间传递的信息，

它可以在内部携带少量的信息，用于在不同线程之间交换数据，一般通过obatin获取

• Handler 顾名思义也就是处理者

它主要是用于发送和处理消息的。发送消息一般是使用 Handler.sendMessage()，而发出的消息经过一系列地辗转处理后，最终会传递到Handler.handleMessage()；

• MessageQueue 是消息队列，

它主要用于存放所有通过 Handler 发送的消息。这部分消息会一直存在于消息队列中，等待被处理，其本质上是一个按时间排序的单向链表；

• Looper 是每个线程中的 MessageQueue 的管家

调用 Looper 的 loop() 方法后，就会进入到一个无限循环当中，然后每当发现 MessageQueue 中存在一条消息，就会将它取出，并传递到 Handler.handleMessage() 方法中。

2. 一个线程有几个Looper？有几个messageQueue？#

一个线程只有一个 Looper对象和一个 MessageQueue 对象。

在创建 Handler 之前，内部需要调用 Looper.prepare() ，该函数保证了每个线程只有一个 Looper 对象。

1
public static void prepare() {
2
    prepare(true);
3
}
4

5
private static void prepare(boolean quitAllowed) {
6
    if (sThreadLocal.get() != null) {
7
        throw new RuntimeException("Only one Looper may be created per thread");
8
    }
9
    sThreadLocal.set(new Looper(quitAllowed));
10
}

而 MessageQueue 又是在 Looper 的构造函数中创建的，保证了一个 Looper 对应一个 MessageQueue

1
private Looper(boolean quitAllowed) {
2
    mQueue = new MessageQueue(quitAllowed);
3
    mThread = Thread.currentThread();
4
}

3. 一个线程可以有几个handler？之间是如何处理正确的Msg的#

因为Handler可以在Activity里创建，在Service里面也可以创建，而Activity全部都跑在了主线程里面，这就证明了主线程中可以有多个Handler。

Handler 在 sendMessageAtTime() 时，会把自身填入 msg.target，因此msg是跟handler绑定起来的

然后在 Looper.loop() 不断从 MessageQueue 中获取 Message 处理的时候，会根据 msg.target 去调用对应的 dispatchMessage ， 这边的 msg.target 就是前面的 handler

4. MessageQueue 的数据结构？多个线程往MessageQueue添加数据，如何保证线程安全？#

MessageQueue 是一种先进先出的数据结构，底层实现是按时排序的单向链表，当有 Message 入队时，按照 Message 的 when 值排序插入，然后出队时则去表头的 Message；

在MessageQueue.enqueueMessage() 和MessageQueue.next() 的时候都会用到同步锁synchronized保证线程安全 https://link.juejin.cn?target=https%3A%2F%2Fwww.wolai.com%2Friveryoung%2FpyMRri9RiZEhrYQ1whzZpT

5. 为什么主线程可以直接new Handler？如果子线程想要new handler需要做哪些工作？#

因为在主线程中已经提前添加了 Looper.prepareMainLooper() 和Looper.loop()， 如果子线程想要调用new handler，需要调用 Looper.prepare() 和Looper.loop()

1
 *  class LooperThread extends Thread {
2
  *      public Handler mHandler;
3
  *
4
  *      public void run() {
5
  *          Looper.prepare();
6
  *
7
  *          mHandler = new Handler(Looper.myLooper()) {
8
  *              public void handleMessage(Message msg) {
9
  *                  // process incoming messages here
10
  *              }
11
  *          };
12
  *
13
  *          Looper.loop();
14
  *      }
15
  *  }

Looper.prepare() 本质是去创建Looper, 而创建Looper的核心要义就是创建一个MessageQueue。可以将Looper看成是流水线的引擎，而MessageQueue就是流水线皮带上的托盘 prepare主要是把线程和looper绑定起来，并且设置了是否允许轮询退出，

其中主线程的looper是默认不退出的

1
public static void prepare() {
2
    prepare(true);
3
}
4

5
private static void prepare(boolean quitAllowed) {
6
    if (sThreadLocal.get() != null) {
7
        throw new RuntimeException("Only one Looper may be created per thread");
8
    }
9
    sThreadLocal.set( new Looper(quitAllowed) );
10
}
11

12
private Looper(boolean quitAllowed) {
13
    mQueue =  new MessageQueue(quitAllowed) ;
14
    mThread = Thread.currentThread();
15
}

6. Handler.postDelayed() 消息时间准确吗？实现原理？#

实际上，这个问题与线程安全性为同一个问题，多线程中线程一旦安全，时间就不能准确；时间一旦准确，线程就一定不安全。 因为多个线程去访问这个队列的时候，在放入队列和取出消息的时候都会加锁，当第一个线程还没有访问完成的时候，第二个线程就无法使用，所以他实际的时间会被延迟。 所以，Handler所发送的Delayed消息时间基本准确，但不完全准确。

实现原理： (https://link.juejin.cn?target=https%3A%2F%2Fwww.jianshu.com%2Fp%2F66fa1a8396ad) postDelayed最终会调用一个带延迟参数的 sendMessageAtTime，然后通过MessageQueue.enqueueMessage将带延迟时间参数的msg按照时间排序插入到MessageQueue。

MessageQueue是一个按时间排序的单向链表，

Looper 从 MessageQueue取msg的时候，会判断当前时间是否到达链表头第一个msg 的延迟时间，如果还没到，就会通过比较延迟时间和当前时间计算出还需要等待的时间，然后通过native函数nativePollOnce进行一个阻塞等待，直到等待时间到达再唤醒线程执行msg;

7. MessageQueue中没有消息的时候会发生什么？为什么Looper.loop不会阻塞主线程？#

MessageQueue 队列为空时，Looper.loop() 的死循环不会退出也不会执行，而是阻塞在MessageQueue.next() 中的 nativePollOnce() 方法中，进入休眠状态，等待新消息到来重新唤醒。这边会涉及到底层linux 的 pipe 和 epoll 机制实现。

8. 为什么Handler死循环不会卡死？和ANR有什么区别#

应用出现ANR卡死和Looper的死循环其实是没有关系的。应用没有消息需要处理的时候，它是在休眠，释放线程了； 而ANR是指消息没来得及处理，比如按键和触摸事件在5s内没有处理掉，或者前台广播在10s内没有处理掉等，导致卡死；

9. IdleHandler 了解么？#

IdelHandler是MessageQueue中的一个静态内部接口，当 Looper 从 MessageQueue中获取的msg为空，或者执行时间未到时，也就是 MessageQueue空闲时就会去回调 IdleHandler.queueIdle()。

1
public static interface IdleHandler {
2
    boolean queueIdle();
3
}

• 如果 queueIdle() 返回 false，则执行完后，该idlehandler会被剔除，也就是只执行一次，
• 如果返回true，则保留，下次MessageQueue进入空闲状态继续执行；

系统源码中使用例子：ActivityThread.handleResumeActivity()中，在 onResume 方法执行完毕后，调用 Looper.myQueue().addIdleHandler(new Idler()) ，去执行一些资源回收，日志打印等不那么着急的任务。除此之外，在做项目 性能优化 的时候也可以使用 IdleHandler，它在主线程空闲时执行任务，而不影响其他任务的执行。

10. 同步屏障了解么？#

可以理解为同步屏障 （https://link.juejin.cn?target=https%3A%2F%2Fblog.csdn.net%2Fu012165769%2Farticle%2Fdetails%2F117781031） 是为Handler消息机制提供的一种 优先级策略，能提高异步消息的优先级。

Handler机制中有三种消息：同步消息，异步消息和屏障消息。

我们正常使用的消息都是同步消息，异步消息可以在Handler构造时设置，也可以通过setAsynchronous进行设置，而屏障消息跟同步消息的区别是target属性为null。 平时我们发送消息时，这个target是不可以为null的。但是在发送屏障消息的时候，target是可以为空的，它本身仅仅是起屏蔽普通消息的作用，所以不需要target。MessageQueue中提供了 postSyncBarrier() 方法用于插入屏障消息

Looper从MessageQueue中取消息时，如果没有遇到屏障消息，那么同步消息和异步消息是一样的，如果遇到屏障消息，则会屏蔽掉该消息之后的所有同步消息，只执行异步消息。

1
@UnsupportedAppUsage
2
Message next() {
3
    for (;;) {
4
        nativePollOnce(ptr, nextPollTimeoutMillis);
5
        synchronized (this) {
6
            Message msg = mMessages;
7
             //如果msg.target为空，也就是说是一个同步屏障消息，则进入这个判断里面
8
            if (msg != null && msg.target == null) {
9
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
10
                //在这个while循环中，找到最近的一个异步消息
11
                do {
12
                    prevMsg = msg;
13
                    msg = msg.next;
14
                } while (msg != null && !msg.isAsynchronous());
15
            }
16
            //找到了异步消息
17
            if (msg != null) {
18
                //如果消息的处理时间小于当前时间 则等待
19
                if (now < msg.when) {
20
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
21
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
22
                } else {
23
                    // Got a message.
24
                    //处理消息
25
                    mBlocked = false;
26
                    //将异步消息移除
27
                    if (prevMsg != null) {
28
                        prevMsg.next = msg.next;
29
                    } else {
30
                        mMessages = msg.next;
31
                    }
32
                    msg.next = null;
33
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
34
                    msg.markInUse();
35
                    //返回异步消息
36
                    return msg;
37
                }
38
            } else {
39
                // No more messages.
40
                //没有找到异步消息则进入阻塞状态，等待被唤醒
41
                nextPollTimeoutMillis = -1;
42
            }
43
            ...
44
}

在UI绘制流程中，就会使用同步屏障和异步消息，保证在Vsync信号过来时，异步任务能被优先处理，从而让绘制任务被及时执行，避免界面卡顿。

另外需要注意的是：同步屏障不会自动移除，使用完成之后需要手动移除，不然会造成同步消息无法处理。也就是上边提到的，通过removeSyncBarrier(int token) 方法进行移除，token就是之前添加屏障时返回的token。

小结下：

• 屏障消息和普通消息区别在于屏幕没有target，普通消息有target是因为它需要将消息分发给对应的target，而屏幕不需要被分发，它就是用来挡住普通消息来保证异步消息优先处理的
• 屏障和普通消息一样可以根据时间来插入到消息队列中的适当位置，并且只会挡住它后面的同步消息的分发
• postSyncBarrier会返回一个token，利用这个token可以撤销屏障
• postSyncBarrier是hide的，使用它得用反射
• 插入普通消息会唤醒消息对了，但插入屏障不会

11. Handler为什么内存泄漏？如何解决？#

原因 Handler的Message被存储在MessageQueue中，有些Message并不能马上被处理，它们在MessageQueue中存在的时间会很长，这就会导致Handler无法被回收。因为Handler是非静态的匿名内部类的实例，它会隐形的持有外部类Activity，从而导致Activity不能被回收，导致Activity泄漏内存 解决方法

1. 使用static 修饰的handler，使用弱引用activity对象，因为要使用activity对象中的成员（因为静态内部类不持有外部类的引用，所以使用静态的handler不会导致activity的泄露）；
2. 单独定义handler，同样可以弱引用activity；
3. 使用内部类的handler，在onDestroy方法中removeCallbacksAndMessages；
4. 还有一种方法是直接使用避免内存泄漏的Handler开源库WeakHandler；

12. 如何创建Message？为什么？#

创建 Message 建议使用Message.obtain()，不要使用new message()。因为 Message 类里维护了一个 sPool 的对象，可以理解为一个 Message 链表，这个链表的默认最大长度为 50。

在 Android 消息机制中，每当一个 Message 对象被处理完成之后，就会被放入这个池中，为我们提供了复用。

当我们调用 Message.obtain()方法时，如果复用池中存在的 Message 对象，我们就不会去创建一个新的 Message 对象。这样就避免频繁创建和销毁 Message 对象带来的性能开销。减小内存的抖动和OOM。

13. HandlerThread#

Handlerthread 是继承于Thread的一个类，用于开启一个带有looper的新线程，可以使用这个looper来创建Handler。

需要注意的是必须调用start() 方法开启线程。因为 start() 可以调用线程的 run() 方法，而 HandlerThread.run()中会调用 Looper.prepare() 和 Looper.loop()，从而为子线程绑定 Looper，相当于做了一层封装，方便用户使用Handler。

通常Handler 和 HandlerThread 的配合使用方式

14. IntentService#

IntentService 是继承于 Service 的基础类， 本质上是一个 Service。主要是用于响应基于 Intent 的异步请求。 客户端通过 startService(Intent) 发送请求，IntentService 接收到请求后开启，并在新建的子线程中按序处理异步的 Intent 请求，在同一时间只有一个请求会被处理。 当完成所有请求后，IntentService 会自行关闭

为什么官方提供了 Service 之后，又提供 IntentService呢？ Service 默认是运行在主线程的，如果我们需要在 Service 中处理一些耗时任务，那么我们还需要去手动的创建线程或者使用线程池去处理耗时任务（否则会出现ANR），然后在处理完以后手动关闭Service，

而 IntentService 已经帮我们做好了这些工作，我们只需要在onHandleIntent中写上耗时任务的代码，就可以在子线程中去执行，因为 onHandleIntent是运行在子线程中的，并且在任务执行完以后，IntentService 会自己执行stopSelf(startId)方法，自行关闭。

用 IntentService 有什么好处呢？ 首先，我们省去了在 Service 中手动开线程的麻烦，第二，当操作完成时，我们不用手动停止 Service。 ServiceIntent 的使用例子，可参考 源码；执行效果如下图： (https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2FRiverYoung%2FAndroidUtils%2Ftree%2Fmaster%2FIntentServiceDemo) (https://cdn.nlark.com/yuque/0/2023/webp/215777/1693499591953-a815c572-2929-4cf6-91ea-e8d305f1e150.webp#averageHue=%233e3e39&clientId=u1dae0b6f-b45a-4&from=paste&id=ude1a7ba3&originHeight=165&originWidth=1188&originalType=url&ratio=2&rotation=0&showTitle=false&status=done&style=none&taskId=u0c04f7d7-5e85-41a2-95ee-8098110c542&title=)

1
/**
2
 * IntentService is an extension of the {@link Service} component class that
3
 * handles asynchronous requests (expressed as {@link Intent}s) on demand.
4
 * Clients send requests
5
 * through {@link android.content.Context#startService(Intent)} calls; the
6
 * service is started as needed, handles each Intent in turn using a worker
7
 * thread, and stops itself when it runs out of work.
8
 */
9
@Deprecated
10
public abstract class IntentService extends Service {
11
    private volatile Looper mServiceLooper;
12
    @UnsupportedAppUsage
13
    private volatile ServiceHandler mServiceHandler;
14
    private String mName;
15
    private boolean mRedelivery;
16

17
    private final class ServiceHandler extends Handler {
18
        public ServiceHandler(Looper looper) {
19
            super(looper);
20
        }
21

22
        @Override
23
        public void handleMessage(Message msg) {
24
            onHandleIntent((Intent)msg.obj);
25
            stopSelf(msg.arg1);
26
        }
27
    }
28

29
    public IntentService(String name) {
30
        super();
31
        mName = name;
32
    }
33
    ...
34

35
    @Override
36
    public void onCreate() {
37
        super.onCreate();
38
        //这边就使用到了 HandlerThread 的工具类
39
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
40
        thread.start();
41

42
        mServiceLooper = thread.getLooper();
43
        // mServiceHandler 本质是 Handler，使用了 mServiceLooper 去创建
44
        mServiceHandler = new ServiceHandler(mServiceLooper);
45
    }
46

47
    @Override
48
    public void onStart(@Nullable Intent intent, int startId) {
49
        Message msg = mServiceHandler.obtainMessage();
50
        msg.arg1 = startId;
51
        msg.obj = intent;
52
        mServiceHandler.sendMessage(msg);
53
    }
54

55
    @Override
56
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
57
        onStart(intent, startId);
58
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
59
    }
60

61
    @Override
62
    public void onDestroy() {
63
        mServiceLooper.quit();
64
    }
65

66
    /**
67
     * This method is invoked on the worker thread with a request to process.
68
     * Only one Intent is processed at a time, but the processing happens on a
69
     * worker thread that runs independently from other application logic.
70
     * So, if this code takes a long time, it will hold up other requests to
71
     * the same IntentService, but it will not hold up anything else.
72
     * When all requests have been handled, the IntentService stops itself,
73
     * so you should not call {@link #stopSelf}.
74
     *
75
     * @param intent The value passed to {@link
76
     *               android.content.Context#startService(Intent)}.
77
     *               This may be null if the service is being restarted after
78
     *               its process has gone away; see
79
     *               {@link android.app.Service#onStartCommand}
80
     *               for details.
81
     */
82
    @WorkerThread
83
    protected abstract void onHandleIntent(@Nullable Intent intent);
84
}

• linux的epoll机制
  • epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

15 Handler 的同步和异步消息机制#

在 Android 开发中，Handler 是线程间通信的重要组件，主要用于在不同线程间发送和处理消息。Handler 支持同步和异步两种消息处理方式。

1
Handler handler = new Handler(Looper.getMainLooper()) {
2
    @Override
3
    public void handleMessage(Message msg) {
4
        // 处理消息
5
    }
6
};
7
// 发送同步消息
8
handler.sendMessage(handler.obtainMessage(1));
9
handler.post(() -> {
10
    // 同步 Runnable
11
});

1
Handler handler = new Handler(Looper.getMainLooper(), null, true) {
2
    @Override
3
    public void handleMessage(Message msg) {
4
        // 处理异步消息
5
    }
6
};

1
Message msg = handler.obtainMessage();
2
msg.setAsynchronous(true);
3
handler.sendMessage(msg);

1
handler.postAtFrontOfQueue(() -> {
2
    // 这个 Runnable 会被优先处理
3
});