一、Android消息机制（handler源码探索）

handler源码探索

Looper(轮询器)

大家都说Looper在android一启动就会启动，但是不看源码，也不知道真假

ActivityThread

public static void main(String[] args) {  
//other code.. 我们只看有用的部分，其他暂略过

Looper.prepareMainLooper();  //准备looper,注，绑定的为当前主线程

ActivityThread thread = new ActivityThread();//开启一个新ActivityThread线程
thread.attach(false);//最后执行到activity
//other code..

 Looper.loop();  //启动looper

AMS创建进程，ActivityThread就被启动了，静态方法就把Looper起来了

ok，回到looper源码中，毕竟不是去AMS源码，点到为止

prepareMainLooper();

public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

prepare()

关于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

threadLocal也是为了解决共享数据（对象）的问题，同步锁的思路是线程不能同时访问一片内存区域，而ThreadLocal的思路是，干脆给每个线程Copy一份一抹一样的对象，各自玩自己的，互相不影响

myLooper()

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

myLooper得到的都是同一个Looper对象

Looper()

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

同时也创建了一个消息队列MessageQueue

myQueue()

你也可以调用myQueue()从Looper得到消息队列

public static @NonNull MessageQueue myQueue() {
    return myLooper().mQueue;
}

当然这都不是最重要的~接下来探索核心方法

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;

    // 确保当前线程是本地进程的唯一标示
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    //开始循环取消息操作
    for (;;) {
        Message msg = queue.next(); //取下一条消息
        if (msg == null) {
            // 如果消息队列没有消息则挂起
            return;
        }

        // 打印日志部分
        Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }
        //调用消息处理逻辑(回调和执行handler处理)
        msg.target.dispatchMessage(msg);

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

        // 确保在处理消息逻辑时当前线程并没有被打断
        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.recycle();
    }
}

启动队列的循环取消息操作，直到调用quit()退出,注释也写的很详细，这也是为什么looper叫做轮询器的原因，他从消息队列中不断拿去消息，用handler去发送

MessageQueue(消息队列)

其实大家对于Looper 和handler 可能都熟一点，对于MessageQueue，就只知道是一个队列，储存的数据的，当然大家理解的也是对的，每次对于有关数据结构的对象，其实我都觉得没啥好看的，无非也就是封装了存，取得方法给外部调用…
分别是：

• enqueueMessage(Message msg, long when)
• next()

next()(取消息)

   final Message next() {
        int pendingIdleHandlerCount = -1; //空闲的idleHandler个数
        int nextPollTimeoutMillis = 0;//下次取消息的时间

        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();//刷新等待命令
            }
            nativePollOnce(mPtr, nextPollTimeoutMillis);//更新下次取消息时间

            //取消息锁
            synchronized (this) {
                if (mQuiting) {//线程正退出
                    return null;
                }

                // 尝试取下一条消息并返回
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    //查找下一个不为空且不是异步的消息
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // 如果当前消息并没到指定时间，则等待nextPollTimeoutMillis 后执行取操作
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // 取一条消息
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (false) Log.v("MessageQueue", "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // 当没有消息时，下次取操作的时间间隔设置为-1
                    nextPollTimeoutMillis = -1;
                }

                // 如果是首次闲置，则获取需要运行的空闲hanlder数量。闲置的hanlder只有在消息队列为空或者当前时间没有消息被处理的时候等待
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0) {
                    // 如果没有闲置handler等待，则消息队列进入阻塞等待
                    mBlocked = true;
                    continue;
                }

                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }

            // 运行闲置handler，我们只有在首次迭代时运行下边这段代码
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; //释放闲置hanlder

                boolean keep = false;
                try {
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf("MessageQueue", "IdleHandler threw exception", t);
                }

                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }

            //重置闲置handler数量
            pendingIdleHandlerCount = 0;

            //当回收闲置handler时候可能有新消息被放进来，所以更新下次取消息时间重新执行
            nextPollTimeoutMillis = 0;
     }
}

next()(存消息)

final boolean enqueueMessage(Message msg, long when) {
        //如果消息正在被使用或者消息的处理handler为空，都会抛异常
        if (msg.isInUse()) {
            throw new AndroidRuntimeException(msg + " This message is already in use.");
        }
        if (msg.target == null) {
            throw new AndroidRuntimeException("Message must have a target.");
        }

        boolean needWake;
        synchronized (this) {
            if (mQuiting) {//如果线程已退出，则抛出异常
                RuntimeException e = new RuntimeException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w("MessageQueue", e.getMessage(), e);
                return false;
            }

            msg.when = when;
            Message p = mMessages;
            if (p == null || when == 0 || when < p.when) {
                // 如果消息处理时间等于0或者小雨队列头的处理时间，则将该消息插至消息队列头
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                //将消息插入对位，通常我们不需要唤醒事件，除非消息队列处在阻塞状态并且这条消息是队列中最早的异步消息
                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;
            }
        }
        if (needWake) {
            nativeWake(mPtr);
        }
        return true;
    }

Handler(快递员)

简单的说他确实有点像快递员

发送消息(发快递)/处理消息(送快递)(子线程切换主线程更新UI)

先看构造方法,怎么与looper还有mQueue关联在一起的

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

    public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

从代码可以看出它从Looper中拿到了消息队列MessageQueue,同时looper也是从构造方法传进来的

接下来看怎么创建Message的

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

在这里谷歌比较建议大家用obtain来创建Message 为什么呢?

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

这下明白了吧~

当然最主要看的还是他送快递,接快递

sendMessage

public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
    public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    }
    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }
    //上述方法都调用sendMessageDelayed()方法
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

最后的方法都在到了sendMessageAtTime中去了

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);
    }
    //还有这个方法
    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }

这里判断了一下MessageQueue是否为空然后继续调用enqueueMessage

enqueueMessage

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

可以看到最后还是把消息(msg)给了消息队列

dispatchMessage

还记得Looper在轮询中分发消息么?

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

就会调用 dispatchMessage

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

    //当message的callback不为空的时候，调用handleCallback
    private final void handleCallback(Message message) {  
        message.callback.run();  
    }  

    //这里是个空方法需要子类定义处理逻辑
    public void handleMessage(Message msg) {
    }

当我们实例化一个handler时候，handler会通过mCallback接口来回调我们的handleMessage方法，看一下这个接口：

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

###End

我们再看看怎么使用handler的~

mHandler=new Handler(){
      @Override
      public void handleMessage(Message msg) {
        switch (msg.what){
          case MSG_UPDATE_TEXT:
            mTv.setText("让Handler更改界面");
            break;

          case MSG_UPDATE_WAY_TWO:
            mTv.setText("让Handler更改界面方式二");
            break;
        }
      }
    };
    mTv.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        Message msg =Message.obtain();
        msg.what= MSG_UPDATE_WAY_TWO;
        mHandler.sendMessage(msg);


      }
    });

• handler.sendMessage()呢,把数据送到消息队列中
• Looper呢,一直在轮询了哦
• 它从消息队列中拿到数据后,又调用handler.dispatchMessage方法
• 最后到了handler中的handleMessage中