从源码分析Handler,Looper,MessageQueue工作机制

前言

首先介绍一下Handler和Looper,MessageQueue分别是做什么的,有什么用!

  • Handler:线程间发送与处理消息
  • Looper:管理MessageQueue消息队列,循环读取MessageQueue中的消息
  • MessageQueue:消息队列
  • Message:消息的载体

首先我们如果在主线程使用Handler的话,肯定是下面的步骤:

handler = new Handler(handlerThread.getLooper()){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Log.d("test","Handler消息!");
            }
};

为什么没有调用Looper的方法呢?
因为主线程已经默认给我们调用了Looper的这个两方法

Looper.prepare();
Looper.loop();

现在我们开始一步一步的分析

  • 先从Looper的prepare和loop两个方法开始:
    prepare方法:
    public static void prepare() {
        prepare(true);
    }

    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是否为空,如果为空就创建一个新的Looper对象,不为空的话就会抛出异常
这就是为什么在一个线程Looper不能调用两次preare()方法的原因

代码中把Looper对象存到了sThreadLocal中,这个sThreadLocal又是什么呢?

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

简单分析下ThreadLocal:

ThreadLocal内部有个ThreadLocalMap类用来存储值的,这个ThreadLocalMap使用键值对进行存储的,在Thread类中有个ThreadLocalMap实例对象,也就是说在每个线程都有一个ThreadLocalMap对象

ThreadLocal存取值方法

ThreadLocal.get方法:

  • ThreadLocal会获取当前Thread的ThreadLocalMap对象然后取出值
    TrheadLocal.set方法
  • ThreadLocal会获取当前Thread的ThreadLocalMap对象然后存入值

假如我们调用Looper的myLooper()方法获取当前Thread的Looper,ThreadLocal就会获取当前Thread来取出当前Thread的ThreadLocalMap对象,然后取出里面的Looper对象

个人觉得ThreadLocal就是可以为各个线程存储其对应的数据

贴出ThreadLocal部分代码:

    public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 取出当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断如果map不为空就取出对应的值
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

    public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 取出当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断如果map为空则进行创建
        // 不为空就进行存值
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    // 获取线程中的threadLocals对象
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

Ok,现在看loop方法
我在代码比较重要的地方注释进行解释

    public static void loop() {
        // 获取了当前Thread的Looper对象
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        // 获取当前Looper的MessageQueue
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        // 开始一个无限循环   
        // for(;;){}这种写法就是无限循环的意思
        for (;;) {
            // 获取MessageQueue中的Message对象
            Message msg = queue.next(); // might block
            // 为空则抛出异常
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            // 我们看这里
            // 这里才是关键的地方
            // 调用Message.target对象的dispatchMessage方法,target其实就是Handler的引用;
            // 而Handler的dispatchMessage方法内部又调用了handleMessage方法去处理
            // 而我们每次创建Handler都会实现handlerMessage方法,是不是有点明白什么了.
            // OK这个我们待会详细再将
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

现在可以看出来,loop方法内部就是开启了一个死循环,不断的从MessageQueue中取出Message进行处理,
通过Message.target.dispatchMessage发送Handler所在的线程取处理

Looper的preare和loop方法分析好了,现在我们开始从sendMessage方法一直往下分析,看下Handler从发送到处理到底经过了哪些流程
关于Handler发送Message有两种发送方式
简单说下区别:

        // 1 每次都会新建Message对象
        Message message = new Message();
        message.what = 0;
        handler.sendMessage(message);

        // 2 会从Message消息池中取出已存在的Message对象进行复用
        handler.obtainMessage(0).sendToTarget();

        // 因为obtainMessage会取出已存在的Message对象进行复用,所以个人建议使用obtainMessage

好的,方便我们的理解,我们就用sendMessage开始分析,
下面是sendMessage调用过程

    public final boolean sendMessage(Message msg)
    {
        // sendMessage方法延时时间为0,就是不延时处理
        return sendMessageDelayed(msg, 0);
    }

    // delayMillis延时时间
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        // SystemClock.uptimeMillis()  // 从开机到现在的毫秒数(手机睡眠的时间不包括在内)
        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);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        // 设置当前消息的目标handler
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

我们调用sendMessage方法发送消息,sendMessage方法最终会走到enqueueMessage方法中,在enqueueMessage方法中,将message的target对象设置为当前handler对象
刚才我们在loop方法中是不是看到使用了message.target对象,原来target是在这里赋值的
然后看方法内部最后调用了queue.equeueMessage方法,也就是说调用了MessageQueue对象的enqueueMessage方法
我们跟着这个方法进入看看

    boolean enqueueMessage(Message msg, long when) {
        // 如果msg.target为空抛出异常
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        // 如果msg正在处理中抛出异常
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        synchronized (this) {
            // 停止
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }

            // 标识消息开始处理
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            // 如果p == null || when == 0 || when < p.when,则将此次消息插入消息队列头部
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                // 将msg的下一个位置设置成当前头部的消息
                msg.next = p;
                // 再将msg赋值为mMessages
                // 就完成了当前消息插入消息队列头部的操作
                mMessages = msg;
                needWake = mBlocked;
            } else { // 将此次消息插入队列末端,或者是插入在延时消息比较长时间的前面
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                // 开启无线循环,其作用就是找到队列的尾部,或者找到比此消息执行时间还要上的消息的上一个位置
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

关于enqueueMessage内部主要进行消息的插入队列中
如果p == null || when == 0 || when < p.when则将该条消息插入队列的头部
(个人理解,p ==null 可能就是第一次插入消息时,when < p.when的时候就是后面插入的消息要比头部的消息先执行,所以插入到头部,先执行意思就是延时时间要比头部的短)
否则就把消息插入队列的尾部,或者插入延时消息比自己时间要长的前一个位置
关于插入延时消息比自己时间要长的前一个位置的解释:
比如现在连续发送两个消息,第一个消息延时1分钟处于消息池中最后一个位置,第二个消息延时3秒的,此时第一个消息会被插入到延时1分钟消息的前面

Ok此时消息已经被插入消息队列,那么还记得刚才的loop方法吗,因为是无限循环方法,所以被插入到队列的消息会被Looper对象取出并处理
看代码:

            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

在loop方法中如果取到message就会调用它的target对象.dispatchMessage方法,刚才已经说了target就是handler对象,现在我们去Handler中的dispatchMessage方法中看看

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

public void handleMessage(Message msg) {
    }

我们先分析msg.callback和mCallback.handleMessage方法,最后再说handleMessage(msg)方法
关于msg.callback和mCallback.handleMessage方法

msg.callback是通过Message对象设置的一个Runnable实现对象,当前消息发送之后会出发该实现方法
关于调用的handleCallback只是竹筏msg.callback的run方法

    private static void handleCallback(Message message) {
        message.callback.run();
    }

关于会走msg.callback的写法

Message m = Message.obtain(handler, new Runnable() {
            @Override
            public void run() {

            }
        });
        m.sendToTarget();

mCallback.handleMessage可以看下面的代码就会明白

 handler = new Handler(new Handler.Callback() {
            @Override
            public boolean handleMessage(Message message) {
                return false;
            }
        });

mCallback是通过构造传入的一个接口,而这个接口中有个方法也是handleMessage(msg)方法
看代码:
Handler内部的CallBack接口
···
/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
*
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public interface Callback {
public boolean handleMessage(Message msg);
}
···

最后说我们重写的handleMessage方法
如果我们没有使用以上两种方式,而是使用重写handleMessage方法,
也就是这种:

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

那么在dispatchMessage中就会走到else的最后面调用了handlerMessage(msg)方法,而我们又实现了handleMessage方法,
所以消息会在handleMessage方法中处理掉;

到此就分析结束了,如有分析错误的地方,欢迎指出,谢谢!
Paste_Image.png

推荐阅读更多精彩内容