Android Handler源码简析

android 开发中，可以在子线程中进行一些操作，然后通过 handler 发送一些数据给主线程更新UI。

主要有如下几部分部分：

Hanlder ：发送和接收消息

Looper ：用于轮询消息队列，一个线程只能有一个 Looper

Message ： 消息实体

MessageQueue ： 消息队列用于存储消息和管理消息

为生产者-消费者模型。

Looper初始化

查看looper的源码

Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call prepare in the thread that is to run the loop, and then loop to have it process messages until the loop is stopped.
Most interaction with a message loop is through the Handler class.
This is a typical example of the implementation of a Looper thread, using the separation of prepare and loop to create an initial Handler to communicate with the Looper.
   class LooperThread extends Thread {
       public Handler mHandler;
 
       public void run() {
           Looper.prepare();
 
           mHandler = new Handler(Looper.myLooper()) {
               public void handleMessage(Message msg) {
                   // process incoming messages here
               }
           };
 
           Looper.loop();
       }
   }

Looper.prepare()

异步线程中的Looper需要主动初始化，主线程的Looper在ActivityThread.main()中执行

Looper.prepareMainLooper();

进行初始化，最终调到

//Looper.java

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));
    }

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

sThreadLocal为静态成员变量，保证每个线程对应一个Looper。

Looper创建完成后，创建了MessageQueue，绑定了Thread。

Looper.loop()

从MessageQueue获取msg，轮询处理消息。

Handler

handler初始化

创建handler时，会初始化对应的MsgQueue和callback

//Handler.java
    public Handler(@Nullable Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> 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());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

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

发送消息

发送的消息会调用到sendMessageAtTime，将消息保存在了消息队列中。最后由

Looper 取出，交给 Handler 的 dispatchMessage 进行处理。

其中，msg的target只向当前handler

    public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        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);
    }


    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);
    }

同步屏障 

https://juejin.cn/post/6844903910113705998

Handler机制——同步屏障_handler同步屏障-CSDN博客