Handler

迷ssssssssssss
241 阅读12分钟

话术

  • Message：需要传递的消息，可以传递数据及对象；
  • MessageQueue：消息队列，但是它的内部实现并不是用的队列，而是通过单链表的数据结构来维护消息列表，因为单链表在插入和删除上比较有优势。主要功能是向消息池投递消息（enqueueMessage）和和取走消息池的消息（next）
  • Handler:消息的真正处理者，主要功能是向消息队列发送消息（sendMessage）和处理对应的消息（handleMessage）
  • Looper：消息轮训器，重要功能是，不断的从消息队列中取出消息交与Handler处理
发送消息 --> 添加消息到队列 --> 从队列中获取消息 --> 处理消息

由Handler发送Message开始，将Message发送到MessageQueue中，由Looper不断的轮训去取MessageQueue中的Message，交给Handler处理 。

一、首先说说发消息这块，send和post，这些方法最终都会调用sendMessageAtTime方法，然后调用enqueueMessage方法，然后在这里将target等于this也就是target和handler进行绑定，然后这里可以设置是否是异步消息，最后调用messageQueue中的enqueueMessage方法，将msg和屏幕亮起的时间戳，加入的messageQueue队列中。

二、再说说messageQueue这个，msg加入到messageQueue的enqueueMessage方法，这块是单链表实现的，消息队列中的消息都是按照时间先后顺序链接起来的（delay是在这里处理的）

三、说完了这些，再说说取消息这块，首先我们都知道app的入口ActivityThread调用的是Looper.prepareMainLooper()，但实际上也是调用了Looper.prepare()。首先设置了prepare(false)false不可以使用quit，然后判断是有sMainLooper了，如果有则抛异常已经mainLooper已经prepare了，如果没有对齐sMainLooper进行赋值 sMainLooper= myLooper（）

现在我们着重说下prepare这个方法，首先他检查了sThreadLocal是否不等于null，如果不等于null就跑出异常一个线程只能有一个looper，然后sThreadLocal调用set方法，然后参数是一个新new出来的looper，在这个looper的构造函数中有创建了messageQueue，以及线程。threadLocal的核心是他的内部类ThreadLocalMap，表明一个Thread只存在一个ThreadLocalMap，他保证了一个线程只有一个Looper对象，一个Looper对象只有一个MessageQueue。前面说的myLooper方法中其实就是sThreadLocal.get(),获取前面set方法中的looper。

接下来就是loop方法了，源码中讲到首先获取到looper对象，根据looper对象获取messageQueue的队列，然后不停的调用messageQueue中的next方法来拿到message。然后通过调用 msg.target.dispatchMessage(msg);也就是handler中的dispatchMessage处理消息。

四、接下来说下messageQueue中的next方法 ，通过源码分析我们发现消息的处理过程，是通过当前消息的执行时间与当前系统时间做比较，如果小于等于当前系统时间则立即返回执行该消息，如果大于当前系统时间则调用 nativePollOnce 方法去延迟等待被唤醒，当消息队列里面为空时则设置等待的时间为 -1。也就是说队列中没有消息的时候会堵塞在next()方法处让CPU休眠，不会ANR。当MessageQueue为空,没有消息或者MessageQueue中最近需要处理的消息是延迟消息时,此时都会尝试执行IdleHandler.

主要涉及的角色如下所示：

  • message：消息。
  • MessageQueue：消息队列，负责消息的存储与管理，负责管理由 Handler 发送过来的 Message。读取会自动删除消息，单链表维护，插入和删除上有优势。在其next()方法中会无限循环，不断判断是否有消息，有就返回这条消息并移除。
  • Looper：消息循环器，负责关联线程以及消息的分发，在该线程下从 MessageQueue获取 Message，分发给Handler，Looper创建的时候会创建一个 MessageQueue，调用loop()方法的时候消息循环开始，其中会不断调用messageQueue的next()方法，当有消息就处理，否则阻塞在messageQueue的next()方法中。当Looper的quit()被调用的时候会调用messageQueue的quit()，此时next()会返回null，然后loop()方法也就跟着退出。
  • Handler：消息处理器，负责发送并处理消息，面向开发者，提供 API，并隐藏背后实现的细节。

整个消息的循环流程还是比较清晰的，具体说来：

  • 1、Handler通过sendMessage()发送消息Message到消息队列MessageQueue。
  • 2、Looper通过loop()不断提取触发条件的Message，并将Message交给对应的target handler来处理。
  • 3、target handler调用自身的handleMessage()方法来处理Message。

事实上，在整个消息循环的流程中，并不只有Java层参与，很多重要的工作都是在C++层来完成的。我们来看下这些类的调用关系。

注：虚线表示关联关系，实线表示调用关系。

在这些类中MessageQueue是Java层与C++层维系的桥梁，MessageQueue与Looper相关功能都通过MessageQueue的Native方法来完成，而其他虚线连接的类只有关联关系，并没有直接调用的关系，它们发生关联的桥梁是MessageQueue。

总结
  • Handler 发送的消息由 MessageQueue 存储管理，并由 Looper 负责回调消息到 handleMessage()。

  • 线程的转换由 Looper 完成，handleMessage() 所在线程由 Looper.loop() 调用者所在线程决定。

Handler 引起的内存泄露原因以及最佳解决方案

Handler 允许我们发送延时消息，如果在延时期间用户关闭了 Activity，那么该 Activity 会泄露。 这个泄露是因为 Message 会持有 Handler，而又因为 Java 的特性，内部类会持有外部类，使得 Activity 会被 Handler 持有，这样最终就导致 Activity 泄露。

解决：将 Handler 定义成静态的内部类，在内部持有 Activity 的弱引用，并在Acitivity的onDestroy()中调用handler.removeCallbacksAndMessages(null)及时移除所有消息。

为什么我们能在主线程直接使用 Handler，而不需要创建 Looper ？

通常我们认为 ActivityThread 就是主线程。事实上它并不是一个线程，而是主线程操作的管理者。在 ActivityThread.main() 方法中调用了 Looper.prepareMainLooper() 方法创建了 主线程的 Looper ,并且调用了 loop() 方法，所以我们就可以直接使用 Handler 了。

因此我们可以利用 Callback 这个拦截机制来拦截 Handler 的消息。如大部分插件化框架中Hook ActivityThread.mH 的处理。

主线程的 Looper 不允许退出

主线程不允许退出，退出就意味 APP 要挂。

Handler 里藏着的 Callback 能干什么？

Handler.Callback 有优先处理消息的权利 ，当一条消息被 Callback 处理并拦截（返回 true），那么 Handler 的 handleMessage(msg) 方法就不会被调用了；如果 Callback 处理了消息，但是并没有拦截，那么就意味着一个消息可以同时被 Callback 以及 Handler 处理。

创建 Message 实例的最佳方式

为了节省开销，Android 给 Message 设计了回收机制，所以我们在使用的时候尽量复用 Message ，减少内存消耗：

  • 通过 Message 的静态方法 Message.obtain()；

  • 通过 Handler 的公有方法 handler.obtainMessage()。

子线程里弹 Toast 的正确姿势

本质上是因为 Toast 的实现依赖于 Handler，按子线程使用 Handler 的要求修改即可，同理的还有 Dialog。

妙用 Looper 机制

  • 将 Runnable post 到主线程执行；
  • 利用 Looper 判断当前线程是否是主线程。

主线程的死循环一直运行是不是特别消耗CPU资源呢？

并不是，这里就涉及到Linux pipe/epoll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质是同步I/O，即读写是阻塞的。所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

handler postDelay这个延迟是怎么实现的？

handler.postDelay并不是先等待一定的时间再放入到MessageQueue中，而是直接进入MessageQueue，以MessageQueue的时间顺序排列和唤醒的方式结合实现的。

一个线程可以有几个Handler,几个Looper,几个MessageQueue对象

一个线程可以有多个Handler，但只有一个Looper对象，一个MessageQueue对象。从Looper.prepare()函数中得知此方法创建了Looper对象，并放入到ThreadLocal中，ThreadLocal内部维护了一个ThreadLocalMap，ThreadLocalMap用来存放线程及相关数据，key就是当前Thread，所以一个线程只能有一个Looper；

在Looper的构造方法中创建了MessageQueue对象。

handler postDealy后消息队列有什么变化，假设先 postDelay 10s, 再postDelay 1s, 怎么处理这2条消息？

postDelay传入的时间，会和当前时间SystemClock.uptimeMills()相加，并不是单纯的延迟时间。延迟消息会和当前消息队列中的消息头执行时间对比，若是比消息头的时间靠前，则作为新的消息头，否则会将此条消息插入到合适的位置；

MessageQueue是什么数据结构

采用单链表的数据结构来存储消息列表

HandlerThread是什么，原理等

HandlerThread 顾名思义就是一种可以使用 Handler 的 Thread。日常开发中我们经常会通过创建一个 Thread 去执行任务，有多个任务就多创建几个线程实现，这时候可能出现线程同步的问题。不过有时候我们并不需要很强的并发性，只需保证按照顺序地执行各个任务即可，有什么好办法实现呢？第一反应想到的可能是通过 Executors.newSingleThreadExecutor() 方法来创建一个 SingleThreadExecutor，来统一所有的任务到一个线程中，然后按顺序执行。其实，除了这个方法之外，HandlerThread 也可以实现。

简单使用

首先创建一个 HandlerThreadActivity

public class HandlerThreadActivity extends BaseActivity {
    
    private static final String TAG = "HandlerThreadActivity";

    private Button mStartBtn;
    private Handler mHandler;
    private HandlerThread mHandlerThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread);
        mStartBtn = findViewById(R.id.start_btn);

        mHandlerThread = new HandlerThread("THREAD_NAME");
        mHandlerThread.start();
        mHandler = new Handler(mHandlerThread.getLooper());

        mStartBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        Log.d(TAG, Thread.currentThread().getId() + " " + String.valueOf((Looper.myLooper() == Looper.getMainLooper())) + " 任务：" + this.hashCode());
                        SystemClock.sleep(3000);
                    }
                });
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandlerThread.quit();
    }
}

快速三击按钮，打印日志如下：

可以发现，三次不同的任务按开始的顺序执行，而且是运行在子线程中，那到底是怎么实现的呢？

源码解析

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;
    private @Nullable Handler mHandler;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    
   
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
    
   
    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        // 获取线程 id
        mTid = Process.myTid();
        //构建一个 Looper
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        //设置线程优先级
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        // Looper 循环
        mTid = -1;
    }
    
     // 获取当前线程的 Looper，
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
       
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }


     /**
     * @return a shared {@link Handler} associated with this thread
     * @hide 方法隐藏掉，无法调用
     */
    @NonNull
    public Handler getThreadHandler() {
        if (mHandler == null) {
            mHandler = new Handler(getLooper());
        }
        return mHandler;
    }

     //线程退出方法，主要是调用 Looper.quit() 方法，不然一直在循环
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

    //同上，不过这个方法会把消息队列中的已有消息处理完才会安全地退出
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

    public int getThreadId() {
        return mTid;
    }
}

通读下来，如果熟悉 Handler 原理的同学大概就明白 HandlerThread 的机制了：

  • HandlerThread 运行 start() 方法，回调 run() 方法。
  • 在 run() 方法中通过 Looper.prepare() 来创建消息队列，并通过 Looper.looper() 方法来开启消息循环。
  • 由于 Loop.loop() 是一个死循环，导致 run() 也是无线循环，因此当我们不需要使用 HandlerThread 的时候，要调用它的 quit() 方法或者 quiteSafely() 方法。

IdleHandler及其使用场景

同步屏障

  • 当MessageQueue.postSyncBarrier发送了一个同步屏障消息后，所有的同步消息(普通Message)都不能被执行,只有被标记为异步的Message才能执行;
  • MessageQueue.removeSyncBarrier移除屏障消息后，普通消息才能正常继续执行；
  • 正常的消息Message.target指向Handler，并且Message默认是同步消息，如果想变成异步消息，可以调用Message.setAsynchronous(true)方法，或者Handler初始化的时候public Handler(boolean async)传入true，之后通过该Handler发送的消息就都是异步消息了
  • 发送同步屏障本质上只是往MessageQueue中插入一个Message.target=null的消息
  • MessageQueue.next方法中检测到有同步屏障消息时，则会开启一个while循环过滤出异步消息继续执行

源码分析

  • MessageQueue.postSyncBarrier 该API不能被APP正常调用，也没有这个必要，因为APP想要不受同步屏障的影响，可以将Message设置为异步消息即可
@UnsupportedAppUsage
@TestApi
public int postSyncBarrier() {
        return postSyncBarrier(SystemClock.uptimeMillis());
}

private int postSyncBarrier(long when) {
        // Enqueue a new sync barrier token.
        // We don't need to wake the queue because the purpose of a barrier is to stall it.
        synchronized (this) {
                final int token = mNextBarrierToken++;
                final Message msg = Message.obtain();//创建一个Message,但是没有设置target
                msg.markInUse();
                msg.when = when;
                msg.arg1 = token;

                Message prev = null;
                Message p = mMessages;
                if (when != 0) {
                        while (p != null && p.when <= when) {
                                prev = p;
                                p = p.next;
                        }
                }
                if (prev != null) { // invariant: p == prev.next
                        msg.next = p;
                        prev.next = msg;
                } else {
                        msg.next = p;
                        mMessages = msg;
                }
                return token;
        }
}
  • MessageQueue.next方法中，根据msg.target == null来判断是同步屏障消息，从而开始while循环只处理异步消息
if (msg != null && msg.target == null) {
        // Stalled by a barrier.  Find the next asynchronous message in the queue.
        do {
                prevMsg = msg;
                msg = msg.next;
        } while (msg != null && !msg.isAsynchronous());
}
  • Handler初始化时可以指定发送的消息是同步的还是异步的
public Handler(boolean async) {
        this(null, async);
}
public Handler(@Nullable Callback callback, boolean async) {
        mAsynchronous = async;
}
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
                long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {//标记为异步消息
                msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
}
  • ViewRootImpl.java中应用同步屏障功能；事件分发消息不受影响，因为设置成了异步消息
void scheduleTraversals() {
        if (!mTraversalScheduled) {
                mTraversalScheduled = true;
                //执行同步前发送同步屏障消息
                mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
                //请求并等待垂直同步信号VSync
                mChoreographer.postCallback(
                                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
                notifyRendererOfFramePending();
                pokeDrawLockIfNeeded();
        }
}
void doTraversal() {
        if (mTraversalScheduled) {
                mTraversalScheduled = false;
                //移除垂直同步屏障
                mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

                if (mProfile) {
                        Debug.startMethodTracing("ViewAncestor");
                }
                //开始真正绘制
                performTraversals();

                if (mProfile) {
                        Debug.stopMethodTracing();
                        mProfile = false;
                }
        }
}
public void dispatchInputEvent(InputEvent event, InputEventReceiver receiver) {
        SomeArgs args = SomeArgs.obtain();
        args.arg1 = event;
        args.arg2 = receiver;
        Message msg = mHandler.obtainMessage(MSG_DISPATCH_INPUT_EVENT, args);
        msg.setAsynchronous(true);//事件分发消息不受影响，因为设置为异步消息
        mHandler.sendMessage(msg);
}

应用场景

  • ViewRootImpl.java中，绘制流程开始之前，会通过主线程的MessageQueue发送一个同步消息屏障，然后开始等待垂直同步信号VSync，等待垂直同步信号这段时间内，所有在主线程Handler发送的同步消息都不能被及时执行，这样做可以保证垂直同步信号到来时可以及时的执行绘制流程，保证UI的流畅性
  • 为了保证我们主线程Handler消息能及时处理，可以调用Message.setAsynchronous(true)方法将Message设置为异步消息

当我们希望能够在当前线程消息队列,空闲时做些事情的时候可以使用.

比如咱们的gc垃圾回收机制

Looper.quit/quitSafely的区别

Looper.quit会调用MessageQueue中的removeAllMessagesLocked方法，会将所有消息全部清空，包括延迟消息、非延迟消息；

Looper.quitSafely会调用MessageQueue中的removeAllFutureMessagesLocked方法，会将延迟消息清空

MessageQueue的next()方法内部原理

调用 MessageQueue.next() 方法的时候会调用 Native 层的 nativePollOnce() 方法进行精准时间的阻塞。在 Native层，将进入 pullInner() 方法，使用 epoll_wait 阻塞等待以读取管道的通知。如果没有从 Native 层得到消息，那么这个方法就不会返回。此时主线程会释放 CPU 资源进入休眠状态

avatar
文章
阅读
粉丝