Handler实现原理及源码解析

一，Handler的使用

1）创建全局静态常量

class Cons{
     static final int MSG_WHAT_0x1000 = 0x1000;
     static final int MSG_WHAT_0x1001 = 0x1001;
}

2）创建Handler对象

private static Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(@NonNull Message msg) {
            switch (msg.what){
                case MSG_WHAT_0x1000:{
                    Log.d("MainActivity","show message-->"+msg);
                }
                case MSG_WHAT_0x1001:{

                }
                break;
                default:
                    throw new IllegalStateException("Unexpected value: " + msg.what);
            }
            return false;
        }
    });

3）Handler消息的发送

handler.sendMessage(handler.obtainMessage(MSG_WHAT_0x1000));

4）移除消息

 @Override
    protected void onDestroy() {
        super.onDestroy();
        handler.removeCallbacksAndMessages(null);
    }

如上便是谷歌官方推荐的Handler使用方式，上述代码可能对一些新手有一些疑问，在此罗列（大佬请绕道）：
Q1，创建Handler时使用了“new Handler.Callback()”而不是如下方式创建：

 private Handler handler = new Handler(){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
        }
    };

Q2，创建Handler对象时，使用了static 对handler对象的修饰
Q3，发送消息时使用了“handler.obtainMessage”而不是直接new
Q4，在onDestroy中调用removeCallbacksAndMessages
接下来就带着以上疑问进入源码分析。

二，Handler源码流程分析

Handler的源码分析在Framework层目前主要涉及到四个类：Handler，Message，MessageQueue，Looper。
1，Looper及MessageQueue对象创建
在AndroidStudio中多次Shift键或者在线源码找到ActivityThread.java类，它便是Android的主线程也称为UI线程，Looper的初始化便在其main函数中

//见源码7310行
 public static void main(String[] args) {
 		//省略若干代码
 		(1)此处调用了创建了Looper对象
        Looper.prepareMainLooper();
       	//省略若干代码
       	（2）开启消息的轮询
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

根据（1）处的代码，进入到Looper类的prepareMainLooper函数中

//见Looper源码119行
 public static void prepareMainLooper() {
 		//调用内部函数进行Looper对象的创建
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
    
private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
       //创建一个Looper对象，并存入到ThreadLocal中
        sThreadLocal.set(new Looper(quitAllowed));
    }
    
 private Looper(boolean quitAllowed) {
 		//创建了一个MessageQueue
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

上述便是Looper的创建过程了，创建了主线程中唯一的Looper对象，并存入到了ThreadLocal，在其构造函数中并创建了一个MessageQueue的消息队列。
关于ThreadLocal，它内部有一个ThreadLocalMap，类似与HashMap的数据结构，其键是当前ThreadLocal，值是要存放的属性。
在Thread.java源码中可以看到其内部有一个 ThreadLocal.ThreadLocalMap threadLocals = null;的内部变量，而我们创建的ThreadLocal最后都会存放到该Map中。
ThreadLocal存放值时其源码如下：

  public void set(T value) {
  		//获取当前线程
        Thread t = Thread.currentThread();
        //获取当前线程中的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        //如果map不为空，则直接存入当前值
        if (map != null)
            map.set(this, value);
        else
        //创建一个ThreadLocalMap并存入当前线程中
            createMap(t, value);
    }

2，开启Looper的轮询
在ActivityThread的main函数中可知，在创建完成Looper后，又调用了Looper.loop()函数，主要目的就是开启消息的轮询。
进入Looper的loop函数

  public static void loop() {
  		//拿到当前Looper对象
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //获取Looper中的MessageQueue，在Looper创建时，会连带创建一个MessageQueue
        final MessageQueue queue = me.mQueue;
        //开启死循环
        for (;;) {
        	//（1）调用MessageQueue的函数不停的从消息队列中取出消息
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
			//省略...
            try {
            	//（2）调用Message中的target（即Handler对象）进行消息的消费
                msg.target.dispatchMessage(msg);
               }
   		//省略...
        }
    }

（1）MessageQueue中的next函数一探究竟,发现其内部也是一个死循环，并返回一个Message对象。

 Message next() {
        //死循环，从队列中取出消息进行消费
        for (;;) {
        //省略...
        }
    }

如上只是消息的消费的过程，接下来，进入分发过程。
3，Handler消息的发送
根据示例代码中，创建一个消息时，都会调用handler对象的send或post函数，进入handler源码。

    public final boolean sendMessage(@NonNull Message msg) {
        return sendMessageDelayed(msg, 0);
    }
    public final boolean sendEmptyMessage(int what)  {
        return sendEmptyMessageDelayed(what, 0);
    }
    
     public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

    
    public final boolean postDelayed(@NonNull Runnable r, long delayMillis) {
        return sendMessageDelayed(getPostMessage(r), delayMillis);
    }
    
    public final boolean postDelayed(Runnable r, int what, long delayMillis) {
        return sendMessageDelayed(getPostMessage(r).setWhat(what), delayMillis);
    }
    
  public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

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

从上诉代码可知，不管是send或者post的消息最后都调用了enqueueMessage函数

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
            //关键代码，把当前handler对象赋值给Message
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //把消息按照执行时间存放到MessageQueue中
        return queue.enqueueMessage(msg, uptimeMillis);
    }

进入到enqueueMessage中，发现我们发送的消息，最后都会调用msg.target = this 把当前Handler对象存放到Message中，在上述Looper的loop轮询中调用的msg.target.dispatchMessage(msg);，就是此时存入的handler对象。

接下来我们就进入Handler中的dispatchMessage函数

 public void dispatchMessage(@NonNull Message msg) {
 		//判断Message中的runable对象是否为空
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
        	//此处就回到了第一章节中的Q1，它首先判断了我们传入的callback不为空，先调用callback的接口实现，
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //如果callback为空的话，调用内部重写函数，即传统的使用方式，最后执行。
            handleMessage(msg);
        }
    }

到此整个Handler的流程大概跑通了
4，Message源码解析

public final class Message implements Parcelable {
    /**
     * User-defined message code so that the recipient can identify
     * what this message is about. Each {@link Handler} has its own name-space
     * for message codes, so you do not need to worry about yours conflicting
     * with other handlers.
     */
    public int what;

    /**
     * arg1 and arg2 are lower-cost alternatives to using
     * {@link #setData(Bundle) setData()} if you only need to store a
     * few integer values.
     */
    public int arg1;

    /**
     * arg1 and arg2 are lower-cost alternatives to using
     * {@link #setData(Bundle) setData()} if you only need to store a
     * few integer values.
     */
    public int arg2;

    /**
     * An arbitrary object to send to the recipient.  When using
     * {@link Messenger} to send the message across processes this can only
     * be non-null if it contains a Parcelable of a framework class (not one
     * implemented by the application).   For other data transfer use
     * {@link #setData}.
     *
     * <p>Note that Parcelable objects here are not supported prior to
     * the {@link android.os.Build.VERSION_CODES#FROYO} release.
     */
    public Object obj;

    /**
     * Optional Messenger where replies to this message can be sent.  The
     * semantics of exactly how this is used are up to the sender and
     * receiver.
     */
    public Messenger replyTo;

    /**
     * Indicates that the uid is not set;
     *
     * @hide Only for use within the system server.
     */
    public static final int UID_NONE = -1;

    /**
     * Optional field indicating the uid that sent the message.  This is
     * only valid for messages posted by a {@link Messenger}; otherwise,
     * it will be -1.
     */
    public int sendingUid = UID_NONE;

    /**
     * Optional field indicating the uid that caused this message to be enqueued.
     *
     * @hide Only for use within the system server.
     */
    public int workSourceUid = UID_NONE;

    /** If set message is in use.
     * This flag is set when the message is enqueued and remains set while it
     * is delivered and afterwards when it is recycled.  The flag is only cleared
     * when a new message is created or obtained since that is the only time that
     * applications are allowed to modify the contents of the message.
     *
     * It is an error to attempt to enqueue or recycle a message that is already in use.
     */
    /*package*/ static final int FLAG_IN_USE = 1 << 0;

    /** If set message is asynchronous */
    /*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;

    /** Flags to clear in the copyFrom method */
    /*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;

    @UnsupportedAppUsage
    /*package*/ int flags;

    /**
     * The targeted delivery time of this message. The time-base is
     * {@link SystemClock#uptimeMillis}.
     * @hide Only for use within the tests.
     */
    @UnsupportedAppUsage
    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
    public long when;

    /*package*/ Bundle data;

    @UnsupportedAppUsage
    /*package*/ Handler target;

    @UnsupportedAppUsage
    /*package*/ Runnable callback;

	//单链表
    /*package*/ Message next;


    /** @hide */
    public static final Object sPoolSync = new Object();
   //缓存池
    private static Message sPool;
    private static int sPoolSize = 0;


    private static final int MAX_POOL_SIZE = 50;

    private static boolean gCheckRecycle = true;

    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }
    
    public static Message obtain(Message orig) {
        Message m = obtain();
        m.what = orig.what;
        m.arg1 = orig.arg1;
        m.arg2 = orig.arg2;
        m.obj = orig.obj;
        m.replyTo = orig.replyTo;
        m.sendingUid = orig.sendingUid;
        m.workSourceUid = orig.workSourceUid;
        if (orig.data != null) {
            m.data = new Bundle(orig.data);
        }
        m.target = orig.target;
        m.callback = orig.callback;

        return m;
    }

如上代码，可知Message其是一个单链表的数据结构。

三，调用流程图

其执行流程如下：

四，答疑

Q1，在已在dispatchMessage源码进行进行解答，这也就是为啥谷歌官方推荐使用callback的方式创建handler
Q2，在创建Handler是，大多时候都是使用的内部类的方式创建，而我们使用Handler时，基本都是在Activity/Fragment中使用的，内部类持有了上下文，会导致内存泄漏的问题，因此使用static进行修饰，当然也可以使用弱引用的方式。

Q3，发送消息时使用了“handler.obtainMessage”而不是直接new？
在Message的源码中，我们发现存在缓存池的概念，调用obtainMessage时，会先从缓存池中取，如果取不到则进行创建并加入缓存池中，这里使用到了设计模式中的享元设计，类似于RecyclerView的复用机制，因为大量的创建Message对象，存在资源浪费的情况，复用Message，可以节约内存开销。

public final Message obtainMessage()
    {
        return Message.obtain(this);
    }

Q4，在onDestroy中调用removeCallbacksAndMessages
答：主要是在页面销毁时，即时的回收消息，防止内存泄漏。

五，面试题解析

1， Looper 的 loop() 死循环为什么不卡死？
为了让主线程持续处理用户的输入，loop() 是死循环，持续调用 MessageQueue#next() 读取合适的 Message。

但当没有 Message 的时候，会调用 pollOnce() 并通过 Linux 的 epoll 机制进入等待并释放资源。同时 eventFd 会监听 Message 抵达的写入事件并进行唤醒。

这样可以空闲时释放资源、不卡死线程，同时能持续接收输入的目的。

彩蛋1：loop() 后的处理为什么不可执行

因为 loop() 是死循环，直到 quit 前后面的处理无法得到执行，所以避免将处理放在 loop() 的后面。

2，异步 Message 或同步屏障
异步 Message：设置了 isAsync 属性的 Message 实例

可以用异步 Handler 发送
也可以调用 Message#setAsynchronous() 直接设置为异步 Message
同步屏障：在 MessageQueue 的某个位置放一个 target 属性为 null 的 Message，确保此后的非异步 Message 无法执行，只能执行异步 Message

原理：当 MessageQueue 轮循 Message 时候发现建立了同步屏障的时候，会去跳过其他 Message，读取下个 async 的 Message 并执行，屏障移除之前同步 Message 都会被阻塞

总结：异步消息一般是系统内部使用的，当handler收到异步消息时，会优先处理异步消息，等到异步消息处理完后，才会处理同步消息，例如vsync信号

3，IdleHandler 空闲 Message
适用于期望空闲时候执行，但不影响主线程操作的任务

系统应用：

Activity destroy 回调就放在了 IdleHandler 中
ActivityThread 中 GCHandler 使用了 IdleHandler，在空闲的时候执行 GC 操作
App 应用：

发送一个返回 true 的 IdleHandler，在里面让某个 View 不停闪烁，这样当用户发呆时就可以诱导用户点击这个 View
将某部分初始化放在 IdleHandler 里不影响 Activity 的启动