首页 > 程序开发 > 移动开发 > Android >

深入理解Android消息机制,从源码解析Handler,Looper,MessageQueue

2017-04-24

深入理解Android消息机制,从源码解析Handler,Looper,MessageQueue。

Android 规定不允许在子线程中更新UI,但是为了保证UI线程(也即主线程)的流畅性,通常一些耗时操作都是在子线程中进行,比如,IO操作,网络请求操作等,这就涉及到一个问题,如果子线程这些操作执行完,想要更新界面的控件显示该怎么办,显然不能直接在子线程操作,否则会抛出异常;为了解决这个问题,Android设计了一套异步消息机制,这包括Handler,Looper,MessageQueue。

1.Handler解析
下面我们先从Handler的使用一步步深入解析,抽丝剥茧;

Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
           //更新UI操作
    mButton.setText(“hello,world”);
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(){
            @Override
            public void run() {
                handler.sendEmptyMessage(123);
            }
        }.start();
}

上面这段代码,相信大家也都很熟悉,通过调用handler.sendEmptyMessage(123);就从子线程切换到了UI线程,进而更新UI;那么这里面都发生了什么呢,我们接着看,点进sendEmptyMessage进去看一下,代码如下:

public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
}

再接着点击sendEmptyMessageDelayed方法,代码如下:

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

我们看到这个方法,创建了一个Message对象,用的是Message.obtain()方法,那为什么他不直接new一个Message对象呢,点进obtain()方法,我们看到,代码如下:

/**
     * Return a new Message instance from the global pool. Allows us to avoid allocating new objects in many cases.
     */
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();
    }

从该方法的注释我们看到:这个方法从全局消息池里面取出一个Message对象给我们用,这样就避免再次创建Message对象,从而节省内存空间,当然如果消息池中没有message对象,他就会new一个新对象,这个就相当于的对象的复用。所以,我们创建Message的时候,最好也要用这种方法,而不是简单粗暴的new Message().
好,我们接着看sendEmptyMessageDelayed这个方法,这个方法创建好message对象之后,并给她的what字段赋值之后,调用了sendMessageDelayed(msg, delayMillis)方法,接着点进去看看,代码如下:

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

首先判断延迟多少秒发送消息,然后又调用了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);
    }

首先,获得一个MessageQueue对象,然后又调用了enqueueMessage(queue, msg, uptimeMillis)方法,接着点进去,

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

首先给msg的target字段赋值为this,也就是我们的handler实例,然后调用queue.enqueueMessage(msg, uptimeMillis);将消息插入MessageQueue中,至此,handler的发送消息的工作终于结束,也即是顺利把消息投递到了MessageQueue中。

2.MessageQueue解析:

MessageQueue内部维护一个单链表,主要用来插入和读取Message操作(读取的同时伴随着删除)
首先我们看一下MessageQueue的enqueue方法:由于代码较长和复杂,我就不贴代码了,而且我们没有必要弄懂每一句代码,该方法的主要作用是将message插入到链表中,下面再看一下next()方法,也即是读取message,同样代码也补贴了,该方法是一个死循环方法,如果MessaQueue中没有消息,会阻塞在那里,如果有新消息来的话,会返回该消息,并讲它从链表中删除。

3.Looper解析

Looper扮演者 消息循环的角色,简单来说就是它会不停轮询MessageQueue中是否有消息,如果有就立即处理,没有就阻塞在那里;那looper是怎么和MessageQueue关联起来的呢,我们先来看一下Looper的构造函数:

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

可以看到,MessageQueue对象正是Looper创建的,我们知道,Handler的工作需要Looper,没有looper的话,创建Handler的对象时就会报错,这一点我们从Handler的构造函数中也能看出来,代码如下:

public Handler(Callback callback, boolean async) {
     ….省略部分代码

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

可以看到,如果looper为空,就会抛出异常;至此,有人要问了,我也没创建Looper对象啊,也能正常用handler啊,那是因为,在主线程中,Android已经帮我们创建好了,Android的入口程序是ActivityThread.java这个类,我们看一下他的主函数:

public static void main(String[] args) {

    ….//省略部分代码
5398
5399        Process.setArgV0("");
5400
5401        Looper.prepareMainLooper();
5402
5403        ActivityThread thread = new ActivityThread();
5404        thread.attach(false);
5405
5406        if (sMainThreadHandler == null) {
5407            sMainThreadHandler = thread.getHandler();
5408        }
5409
5410        if (false) {
5411            Looper.myLooper().setMessageLogging(new
5412                    LogPrinter(Log.DEBUG, "ActivityThread"));
5413        }
5414
5415        // End of event ActivityThreadMain.
5416        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
5417        Looper.loop();
5418
5419        throw new RuntimeException("Main thread loop unexpectedly exited");
5420    }

可以看到,Looper.prepareMainLooper();这句就已经创建了Looper,点进这个方法看看,我们看到,最终调用了prepare()这个方法,
我们看一下这个方法:

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

这个方法里面,通过ThreadLocal类型的变量来保存Looper实例,关于ThreadLocal,简单来说,就是,它会保存一个与当前线程相关的唯一一个对象,即每个线程里只创建一个Looper对象,关于他的介绍,我会再写一篇文章,现在我们就简单了解下。
Looper最关键的一个方法就是loop() ,调用这个方法后,消息系统就真正运转起来了,代码如下:

public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn&#39;t called on this thread.");
        }
        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 (;;) {
            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.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            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&#39;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的next方法,来查看消息队列是否有消息,一旦有消息了,就会调用msg.target.dispatchMessage(msg);这句来出来消息,target就是我们的handler对象,下面我们再来看一下dispatchMessage(msg)这个方法:

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

先看第一行,如果callback不为空,就调用handleCallback来出来,这个callback是一个Runnable类型的对象,当我们使用handler的post方法投递消息时,传递的就是一个Runnable类型的参数,看一下代码:

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
我们在看一下getPostMessage方法:

private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

至此我们看到,这个runnable类型的对象赋值给了message的callback字段,然后返回一个Message对象,接着调用sendMessageDelayed把消息发出去了,很巧妙是不是。所以除了使用sendmessage发送消息之外,也可以使用post这种方式放松消息。接下来,我们接着看上面dispatchMessage这段代码,如果没有使用post这种方式,代码就会走到else里面,然后判断mCallback是否为空,mCallback是Callback类型,他是Handler的内部的一个接口,代码如下:

public interface Callback {
        public boolean handleMessage(Message msg);
    }

那么这个mCallback,在哪里赋值的呢,搜索一下看到,在Handler的另一个构造函数的参数里有这个类型,我们可以这样使用:

handler = new Handler(new Handler.Callback() {
            @Override
            public boolean handleMessage(Message msg) {
                //do something
                return false;
            }
        });

这样算是handler的另外一种创建方式吧;我们还是看上面dispatchMessage那段代码,如果mCallback不为空,就执行callbackd的handleMessage方法,如果为空,就执行handler的handleMessage方法;这里我们总结一下dispatchMessage方法,他的处理方式是:如果message的callback不为空,就执行callback的run方法,如果为空,再判断mCallback是否为空,不为空就执行mCallback的handleMessage,为空就执行handler本身的handleMessage方法;
优先级是:message.callback—>Handler.Callback—>Handler.handleMessage

至此,消息从发送到处理,我们就分析完了,也就从当初在子线程发送消息,过渡到到在UI线程处理消息,很巧妙是不是。(注意:不是说只能在子线程发送消息,主线程同意也可以。)
下面我们再来看一张图:这张图是一位大神画的,已经很好了,我就不再画了

Android消息机制图解

这张图我再简单解释一下:首先handler把消息发送到MessagQueue的单链表中,然后Looper立刻就检测到有消息来了,然后调用msg.target.dispatchMessage()来让handler来处理消息,由于handler是在主线程创建的,所以也就是已经来到主线程来操作UI了。

至此,Android消息机制我们就分析完了。

相关文章
最新文章
热点推荐