码迷,mamicode.com
首页 > 其他好文 > 详细

Handler消息机制 源码解读

时间:2016-05-16 11:10:30      阅读:225      评论:0      收藏:0      [点我收藏+]

标签:

基本概念

Handler消息机制的作用

大家知道子线程没有办法对UI界面上的内容进行操作,如果操作,将抛出异常:CalledFromWrongThreadException,为了让子线程能间接操作UI界面,Android中引入了Handler消息传递机制,通过Handler切换到主线程进行UI操作。

Handler、Looper、MessageQueue、Message的关系是什么?

  • Handler用于发送和处理消息。而发出的Message经过一系列的周转后,最终会传递回Handler中,最后更新UI。

  • Message是在线程之间传递的消息,它可以在内部携带少量的信息,用于在不同线程之前交换数据。

  • MessageQueue是消息队列,用于存放Message。Message在消息队列中,等待Looper取出。每个线程中只会有一个MessageQueue对象。

  • Looper是每个线程中的MessageQueue的管家,调用Looper的loop()方法后,就会进入一个无限循环中,每当MessageQueue中存在一个Message,Looper对象就会将其取出,传递到Handler中进行处理。每个线程中只会有一个Looper对象。

Handler消息机制疑问

从上面的基本概念中,我们不难会产生疑问,比如:

  • 在Message的周转过程中,是怎么切换到主线程的?
  • 如果当前线程中new了多个Handler,它们发送消息后会错乱吗?会不会找错Handler对象。
  • Handler的post方法和sendMessage有什么区别?
  • 怎么保证每个线程中只能存在一个Looper和MessageQueue?
  • 子线程为什么不能直接new Handler?
  • 主线程为什么不用手动创建Looper?
  • 主线程中的Looper无限循环,为什么没有造成ANR?

下面,我将从源码角度,对以上疑问进行探索。看完本篇博客,相信你心里就会有答案了。

初识API

Message

我们先来简单认识一下Message

    public int what;
    public int arg1; 
    public int arg2;
    public Object obj;

上面几个的用法,大家都知道,就不用介绍了。我们来看看下面的。

    Handler target;
    Runnable callback;

Message中可以保存Handler对象,也可以保存Runnable,具体用法看完本篇博客就知道了。
还记得Message.obtain用法吗?

 public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; 
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

因为Message被处理完过后,是不会直接回收的,默认会保存一定数量的Message以供复用。我们可以使用Message.obtain复用,以免创建多余的Message。

MessageQueue

MessageQueue是什么?我们可以给它理解成一个集合,比如List,我们可以添加消息,也可以读取消息,移除消息。当然MessageQueue的内部是通过一个单链表的数据结构来实现的,理解起来可能有点费劲,我们只需知道有两个重要的方法enqueueMessage插入消息,next取出消息。

  //======================插入消息=================================
    boolean enqueueMessage(Message msg, long when) {
            //...
            //省略了部分代码
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                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;
    }


    //======================取出消息=================================

Message next() {
             //...
            //省略了部分代码
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
              //...
            //省略了部分代码
        }
    }

工作原理

发送消息(将Message提交到MessageQueue)

Handler平时用的都比较多,一般都会直接使用 mHandler.sendMessage进行发送消息,然后重写Handler的handleMessage进行接收和处理消息。那么 mHandler.sendMessage 到底做了什么事呢?

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

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

我们可以发现,在Handler内部,其实调用的是sendMessageDelayed,然后sendMessageDelayed中又调用了sendMessageAtTime

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

sendMessageAtTime中我们看到了什么?没错MessageQueue,而且MessageQueue不可为空,否则会抛出异常,你可能为疑问,这个MessageQueue是从哪里来的,不要急,下面马上就会介绍,在Handler的构造方法那里就能看到。我们暂且不管MessageQueue是怎么工作的,我们只需知道,我们当前的任务是将Message塞进MessageQueue中,我们接下来看看enqueueMessage中做了什么。

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

我们可以发现,这里调用了MessageQueue中的queue.enqueueMessage方法将Message插入到队列中去,到此为止,我们完成了第一步。
我们还能发现这一行msg.target = this;,没错,将当前的Handler对象绑定给了Message,这也就能解释,为什么Message一番周转之后,仍然知道该传递给哪个Handler对象。

取出消息(将Message从MessageQueue中取出)

Message塞给了MessageQueue后,现在就该轮到Looper登场了。Looper是怎么从MessageQueue取出中取出Message的呢。

Looper的属性

先来简单看一下Looper的三个属性。

    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    private static Looper sMainLooper; 
    final MessageQueue mQueue;

可以看出Looper中会绑定一个对应的MessageQueue,还有一个线程变量sThreadLocal

子线程中为什么不能直接创建Handler

在介绍之前,我们先来解释下,为什么不能直接在子线程中new Handler。
大家都知道在线程中使用Handler如下,但是可能不知道为什么要这么写。

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

那么,我们先来看一下Handler构造方法,Handler构造方法有两种,一种是显示指定Looper对象的,另一种是不显示指定Looper的(会默认获取当前线程的Looper),所有不显示指定Looper的构造方法都会在内部转为调用以下构造。

public Handler(Callback callback, boolean async) {
        //...
        //省略了部分代码
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can‘t create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

我们可以发现只要mLooper为空,就会抛出异常。不为空的话就连同MessageQueue赋值给当前Handler,你可能又想问,Looper的MessageQueue是怎么来的,莫急,待会会介绍Looper的构造方法。我们先看看Looper.myLooper()方法

    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

sThreadLocal是什么鬼?

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

看到这里终于明白了,原来用了ThreadLocal啊,ThreadLocal是Java用来存储线程变量的api。也就是说,假如我们在主线程使用sThreadLocal存储了一个Looper,在子线程也使用了sThreadLocal存储了一个Looper,他们互不干扰。每个线程取出来的值都是不一样的。这也就保证了,每一个线程都有一个单独的Looper。
那么如何在子线程使用Handler呢?相信大家都有思路了,只要保证sThreadLocal.get()能取到值就行,我们可以在new 之前给当前线程一个Looper对象。api中已经提供了方法,Looper.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对象呢?当然是因为Android的单线程模型啊。如果允许多个Looper那么和在子线程中直接处理没有任何区别,会导致一系列的并发问题。

sThreadLocal.set(new Looper(quitAllowed))给当前线程绑定一个Looper,我们来看一下Looper的构造。

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

从源码可以看出,与此同时,也给Looper绑定了一个MessageQueue对象。

Looper取消息

那么,Looper到底是怎么从MessageQueue中取出Message的呢。我们来看下 Looper.loop()

    public static void loop() {
        final Looper me = myLooper();//获取当前线程的Looper
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn‘t called on this thread.");
        }
        final MessageQueue queue = me.mQueue; //获取Looper对应的消息队列
         //...
         //省略了部分代码
        for (;;) {//死循环
            Message msg = queue.next();  //从消息队列中取出一下个Message
              //...
             //省略了部分代码
            msg.target.dispatchMessage(msg);//msg.target就是Handler,调用Handler的dispatchMessage方法处理消息

              //...
             //省略了部分代码
            msg.recycleUnchecked();//回收Message
        }
    }

流程非常清晰,通过一个死循环,不停调用MessageQueuenext()方法,取出Message,然后看到了没msg.target,前面我们发送消息时,绑定的Handler对象。经历了一番周转变换了线程,又交给了Handler对象的dispatchMessage中进行处理消息。

处理消息(Handler调用dispatchMessage处理消息)

在介绍处理消息之前,我们先来认识一下Handler的其他使用方法。我们知道只要重写Handler的handleMessage方法,然后就可以接收消息了。但是,我如果不想重写handleMessage呢?有没有其他方法?当然是有的,请往下看。

Handler的构造参数

前面我也提到了,Handler的构造方法分为两种,显示指定Looper与否,其实这两种都是一样的,没有本质上的区别。但是我们忽略了Handler构造方法中的其他参数,现在再来看一遍。

public Handler(Callback callback, boolean async) {
        //...
        //省略了部分代码
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can‘t create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

有没有发现一个Callback参数,其实它是一个接口,也是用于处理消息的。

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

使用mHandler.post发送消息。

mHandler.sendMessage这种方法大家都很常用,也很简单。大家都知道Handler有个post方法,那么它和sendMessage有什么区别呢?我们来看一下源码。

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

从上面可以看出,使用post,仍然会包装为Message,然后调用sendMessageDelayed进行发送消息。先来看一下到底是怎么包装的,如下

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

包装给了一个callback,就是前面提到的Runable。

Handler处理消息

在介绍完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);
        }
    }

看到没有,if (msg.callback != null),也就是说,如果是使用post发送的,会调用handleCallback进行处理。

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

直接走了Runable的run方法。不会走Handler的handleMessage
然后 if (mCallback != null)判断那个接口有没有实现,如果实现了,直接走接口。最后才是调用Handler内部的handleMessage方法。

最后

  • 主线程为什么不用手动创建Looper?

我们来看一个类ActivityThread,这个类是Android的入口,我们可以找到一个久违的方法public static void main(String[] args)

    public static void main(String[] args) {
       //...
       //省略了部分代码

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        //...
       //省略了部分代码
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

从上面可以看出,Android在启动一个应用时,已经默认给主线程开启了Looper。

  • 主线程中的Looper无限循环,为什么没有造成ANR?

什么情况下会造成ANR呢?只有当主线程的Handler处理一个消息耗时过长才会ANR。
Looper无限循环,不是一个简单的死循环,当消息队列中没有消息时,就会阻塞休眠,释放cpu资源。
我们Activity之所以有生命周期,也依赖于Handler,是因为ApplicationThread根据系统ActivityManageService发来的事件,然后发送消息来调度生命周期的。以下是ActivityThread中处理消息相关的部分代码。

 public void handleMessage(Message msg) {
              //..
            //省略了部分代码
            switch (msg.what) {
                case LAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;

                case PAUSE_ACTIVITY:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                    handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,
                            (msg.arg1&2) != 0);
                    maybeSnapshot();
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
             //..
             //省略了部分代码
            }

        }

END

Handler消息机制 源码解读

标签:

原文地址:http://blog.csdn.net/maplejaw_/article/details/51422308

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!