黑马程序员技术交流社区

标题: Handler 消息机制(源码分析) [打印本页]
作者: 李印东老师    时间: 2014-7-29 22:56
标题: Handler 消息机制(源码分析)
本帖最后由 李印东老师 于 2015-3-27 09:15 编辑

Handler 消息机制(源码分析)
其中有四个关键对象分别是: Message,Handler, MessageQueue, Looper.

创建一个Message消息对象.
  1.    Message msg = new Message();
  2.    // 先去消息池中去取, 如果没有再new一个
  3.    Message msg = Message.obtain();
复制代码

创建一个Handler对象, 以下是Handler类的构造函数代码片段:
  1.    public Handler() {
  2.        ...         

  4.        // 取得Looper对象
  5.        mLooper = Looper.myLooper();
  6.        if (mLooper == null) {
  7.            throw new RuntimeException(
  8.                 "Can't create handlerinside thread that has not called Looper.prepare()");
  9.        }
  10.        // 消息队列
  11.        mQueue = mLooper.mQueue;
  12.        mCallback = null;
  13.     }
复制代码

调用sendMessage方法发送一个消息.
  1.    public final boolean sendMessage(Message msg) {
  2.        // 1. 转调sendMessageDelayed
  3.        return sendMessageDelayed(msg, 0);
  4.     }

  6.    public final boolean sendMessageDelayed(Message msg, long delayMillis) {
  7.        if (delayMillis < 0) {
  8.            delayMillis = 0;
  9.        }
  10.        // 2. 转调sendMessageAtTime
  11.        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
  12.     }

  14.    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
  15.        boolean sent = false;
  16.        MessageQueue queue = mQueue;
  17.        if (queue != null) {
  18.            // 3. 这里把msg的target参数赋值为this(当前的Handler对象)
  19.            msg.target = this;
  20.            // 4. 把消息传递给消息队列MessageQueue.
  21.            sent = queue.enqueueMessage(msg, uptimeMillis);
  22.        } else {
  23.            RuntimeException e = new RuntimeException(
  24.                 this + "sendMessageAtTime() called with no mQueue");
  25.            Log.w("Looper", e.getMessage(), e);
  26.        }
  27.        return sent;
  28.     }
复制代码

MessageQueue类, 通过enqueueMessage方法接收Message消息对象, 并按照先后或者时间顺序排列好.
  1.    final boolean enqueueMessage(Message msg, long when) {
  2.        ...         

  4.        final boolean needWake;
  5.        synchronized (this) {
  6.            ...

  8.            msg.when = when;
  9.            //Log.d("MessageQueue", "Enqueing: " + msg);
  10.            Message p = mMessages;
  11.            if (p == null || when == 0 || when < p.when) {
  12.                 msg.next = p;
  13.                 mMessages = msg;
  14.                 needWake = mBlocked; // newhead, might need to wake up
  15.            } else {
  16.                 Message prev = null;
  17.                 while (p != null &&p.when <= when) {
  18.                     prev = p;
  19.                     p = p.next;
  20.                 }
  21.                 msg.next = prev.next;
  22.                 prev.next = msg;
  23.                 needWake = false; // stillwaiting on head, no need to wake up
  24.            }
  25.        }

  27.        ...

  29.        return true;
  30.     }
复制代码

接下来就是Looper轮循器了, 它的工作就是不停的去MessageQueue队列中取消息. Looper的实例对象是在ActivityThread的main方法中初始化的. ActivityThread的main函数, 代码片段如下:
  1.    public static final void main(String[] args) {
  2.        ...

  4.        // 准备主线程的Looper轮循器, 内部会创建一个Looper对象.
  5.        Looper.prepareMainLooper();
  6.        if (sMainThreadHandler == null) {
  7.            sMainThreadHandler = new Handler();
  8.        }

  10.        ActivityThread thread = new ActivityThread();
  11.        thread.attach(false);

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

  18.        // 开始轮循.
  19.        Looper.loop();

  21.        ...
  22.     }
复制代码

Looper类中的loop方法, 代码片段如下; 注意: 这里loop方法是一个while(true)的死循环, 这就引发一个问题: 会不会阻塞主线程? 答案是: Looper的底层涉及到Linux下的管道(Pipe), 管道可以实现进程间通信, 管道内部实现原理: 是由一个特殊的文件来实现的, 此文件的两端有两个描述符, 一个用于读取, 一个用于写入. 这样的话主线程在等待其他线程写入, 如果其他线程写入后会唤醒主线程, 这样的话主线程开始循环取消息, 如果没有消息了, 主线程又开始进入等待(挂起)状态.
  1.    public static final void loop() {

  3.        // 获得主线程Looper对象
  4.        Looper me = myLooper();
  5.        // 获得消息队列
  6.        MessageQueue queue = me.mQueue;
  7.        while (true) {  // 循环的去消息队列MessageQueue中取消息.
  8.            // 注意: 如果消息队列中没有消息, 下面这一步就会使主线程进入挂起状态, 直到被唤醒, 再继续取消息, 分发消息.
  9.            Message msg = queue.next(); // might block
  10.            if (msg != null) {
  11.                 if (msg.target == null) {
  12.                     // No target is a magicidentifier for the quit message.
  13.                     return;
  14.                 }
  15.                 if (me.mLogging!= null)me.mLogging.println(
  16.                        ">>>>> Dispatching to " + msg.target + ""
  17.                         + msg.callback +": " + msg.what
  18.                         );

  20.                 // 调用target的dispatchMessage方法分发消息
  21.                msg.target.dispatchMessage(msg);
  22.                 if (me.mLogging!= null)me.mLogging.println(
  23.                        "<<<<< Finished to   " + msg.target + " "
  24.                         + msg.callback);
  25.                 msg.recycle();
  26.            }
  27.        }
  28.     }
复制代码

Looper调用了Message中的target的dispatchMessage方法分发消息, 上面Handler发送消息时,msg.target对象其实就是Handler自己.Handler的dispatchMessage方法如下:
  1. public void dispatchMessage(Message msg) {
  2.    if (msg.callback != null) {
  3.        handleCallback(msg);
  4.     }else {
  5.        if (mCallback != null) {
  6.            if (mCallback.handleMessage(msg)) {
  7.                 return;
  8.             }
  9.        }
  10.        // 调用了自己的handleMessage方法.
  11.        handleMessage(msg);
  12.     }
  13. }

  15. // 此方法是空实现. 是由我们自己定义的Handler对象中实现的.
  16. public void handleMessage(Message msg) {
  17. }
复制代码

至此为止, 发送一个消息最终被Handler的handleMessage方法接收到.





作者: ò壞尛孩    时间: 2014-7-29 23:12
{:3_67:}!收藏了~  等需要的时候慢慢研究!
作者: 满眼温柔    时间: 2014-7-29 23:29
先收藏了再说，顶 ！！！！！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2