Handler

Handler消息机制

Message

创建Message的方法:

1. Message msg=new Message()
2. Message msg=Message.obtain()
3. handler.obtainMessage()

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

这里的obtain方法 , 为一个链表的插入操作

MessageQueue

存放Message的数据结构 , 为单向链表 .
默认的msg的when都是0 ,后加的放在最前面.
如果when!=0 , 那么when值小的放在前面

Handler

消息处理类 , 用于UI的处理

Looper

轮询器,Linux底层的管道通信

Handler消息处理过程

Handler的创建

Handler handler=new Handler(){
      handlerMessage(Message msg){
              //更新UI    
      }
}

准备sThreadLocal

1. 在ActivityThread中初始化Looper
   Looper.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();
        }
    }

3. 点开prepare()方法 , 能发现我们要找到的东西 , 填充线程容器, 在Handler的默认构造方法中取值.
   线程容器可以收集线程并通过set来设置线程的tag ,同时通过get(tag)来获取到想要的线程

private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //创建一个Looper , 将其加入到线程容器中
        sThreadLocal.set(new Looper(quitAllowed));
    }

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;
        //空构造函数 , 将callback置空
        mCallback = callback;
        mAsynchronous = async;
    }

1. Looper.myLooper();

public static @Nullable Looper myLooper() {
        //从线程容器中获取线程 , 上文中提到线程变量的加入, 在这里取值,得到轮训器对象
        return sThreadLocal.get();
    }

2. mQueue = mLooper.mQueue; //获取轮询器的消息队列

Handler发送消息

1. handler.sendMessage(); //发送消息

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

2. 跟进sendMessageDelayed方法:

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

在这个方法体中 , 我们调动的sendMessage方法不传入时间 , 在这里默认置为0 .然后跟进她的返回值的方法:sendMessageAtTime

3. sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        这个mQueue为Handler中构造函数赋值, 为轮询器的消息队列
        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);
    }

4. enqueueMessage方法

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        // 把自己的handler和message做了绑定 , 这个方法在Handler类中 , 所以这里的this就是Handler的实例
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //将消息按时间顺序入队列 , queue为上文提到的队列
        return queue.enqueueMessage(msg, uptimeMillis);
    }

5. enqueueMessage:
   按照时间顺序进入队列 , 如果是队首 , 会进行唤醒操作 .
   排序: 按消息的时间排序 , 如果时间一样, 后加的排在前面

Looper轮询器取消息

在应用程序启动前 ,
ActivityThread的main方法已经执行并开始准备接收消息
1, looper.loop方法

2. 在循环中 ,获取到消息就执行分发消息的操作
   msg.target.dispatchMessage(msg)
   调用Handler的dispatchMessage分发消息.

public void dispatchMessage(Message msg) {
         //如果没有callback说明调用了runOnUIThread方法
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //在主线程中 ,调用Handler的handlerMessage处理消息 , 这里为类内部的接口的接口方法
            handleMessage(msg);
        }
    }

3. 主线程中 , 调用Handler的handlerMessage来处理消息
4. msg.recycler();
   message的回收清理

void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }