Handler,Message,Looper,MessageQueue源码解析

好久不看源码了，心生畏惧，所以这一周抽出时间来看看Handler相关源码

感谢下面几位博主的博客

你真的懂Handler的消息机制吗？
Android Handler机制(四)—Handler源码解析

我们是如何使用Handler的？

public class HandlerActivity extends AppCompatActivity {

    private TextView text;
    private Handler workHandler;
    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            text.setText(msg.what + "秒就要双十一啦!");
        }
    };

  new Thread(new Runnable() {
            @Override
            public void run() {
                Message msg = Message.obtain();
                handler.sendMessage(msg);
            }
        }).start();
}

 handler.post(new Runnable() {
                @Override
                public void run() {
                    text.setText(finalI + "秒就要双十一啦!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

我们日常开发中使用Handler最多的方式就是sendMessage和post这两种了,接下来让我们一步一步往深了看看他们的底部是如何运行的

源码1.0
public final boolean sendMessage(Message msg)
 {
   return sendMessageDelayed(msg, 0);
 }

源码1.1
  public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

我们可以看到无论是调用post还是sendMessage,底部处理都是调用sendMessageDelayed方法，但是如果调用post方法是将Runable对象封装成了一个Message对象

源码1.2
 private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r; //注意这里callback是被赋值了的
        return m;
    }

我们继续看sendMessageDelayed方法里面做了什么操作

源码1.3
  public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

 public boolean sendMessageAtTime(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);
    }

sendMessageDelayed底部调用的是sendMessageAtTime，sendMessageAtTime里面是把Message存到MessageQueue 中，那么我们就好奇了这个mQueue是怎么来的？enqueueMessage里面又干了什么呢？

查看Handler类的成员变量，我们可以看到下面的几个成员变量

源码1.4
  final Looper mLooper;
    final MessageQueue mQueue;//这就是我们要的mQueue
    final Callback mCallback;
    final boolean mAsynchronous;
    IMessenger mMessenger;  //这个类接口是可以进行跨进程交互的，暂时不管

也就是说很有可能构造Handler的时候这些个成员变量都被初始化了，所以才可以sendMessageAtTime的时候将Message发送到MessageQueue中，我们查看下构造方法

源码1.5
public Handler() {
        this(null, false);
    }

 public Handler(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();//获取mLooper
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;//mLooer里面的消息队列
        mCallback = callback;
        mAsynchronous = async;
    }

当我们new Handler的时候，Looper.myLooper()初始化一个mLooper,mQueue 也就是mLooper的成员变量，这下我们知道了mQueue的来历，我们先不着急往Looper里面看，先回到上面那个问题看下enqueueMessage干了什么？

源码1.6
 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;//注意这句话，msg的target设置为当前的handler
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

MessageQueue 里面的enqueueMessage方法我不贴了，有点长，意思是把消息存放到队列里面

Handler,Message,MessageQueue大致做了什么我们都清楚了但是Looper做了什么？我们一无所知那么我们就去看看到底这个Looper干了啥,
源码1.5中我们知道Handler通过 mLooper = Looper.myLooper()获取了 mLooper

源码1.7

  static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    private static Looper sMainLooper;  // guarded by Looper.class

    final MessageQueue mQueue;
    final Thread mThread;
 public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

mQueue,sThreadLocal 都是Looper类的成员变量
既然sThreadLocal是成员变量，既然是get方法，与之对应应该有set方法

源码1.8
  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.prepare方法set进去一个Looper这样才可以myLooper获取到mLooper，可是我们自己的代码没有调用Looper.prepare啊？是不是Handler源码调用了呢？查看了下也是没有的。。。

那我们看看Looper.prepare这个方法被谁调用过呢？

源码1.9  
public static void prepareMainLooper() {
        prepare(false);//被调用啦
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

我们继续刨根问底，看看prepareMainLooper被谁调用了？果不其然是ActivityThread的main方法调用了prepareMainLooper，ActivityThread是app启动的线程，也就是主线程，也就意味着app启动的时候已经set进去一个Looper了，我们后面的Handler自然而然可以取出来Looper

源码2.0
 public static void main(String[] args) {
        ..................
        Looper.prepareMainLooper();
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();
        ...........
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

我们可以看到 Looper.loop()这行代码，这行代码做了什么操作呢？

源码2.1

 /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

      .................
        for (;;) {//死循环
            Message msg = queue.next(); //取出来一个消息
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

          ..................
            try {
                msg.target.dispatchMessage(msg);//如果有消息的话就去处理
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            msg.recycleUnchecked();
        }
    }

msg.target这个变量是谁？她进行了dispatchMessage操作又是什么呢？
重新查看源码1.6，我们知道msg.target就是Handler

源码2.2
 public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

msg.callback这个回调是什么？怎么有点熟悉？查看源码1.2我们就知道了，现在如果是采用post方式会调用 handleCallback(msg);一般的方式会调用 handleMessage(msg);
接下来看看二者有什么不同？

源码2.3 
 private static void handleCallback(Message message) {
        message.callback.run();//去调用了Runable的run方法而并没有新开线程
    }

 public void handleMessage(Message msg) {
   //这是一个空方法，没错这就是我们一般重写的方法
    }

至此就把整个Handler消息处理的框架梳理了一遍，背概念过于枯燥，只有看了源码才知道整个过程，理解才可以更好的记忆。