学习并理解 handler，looper，message之间的关系

学习并理解 handler，looper，message之间的关系
先看 Looper 源代码

private Looper() {  **//3,创建Looper**
// 创建一个新的消息队列
    mQueue = new MessageQueue();

    mRun = true;

// 将创建的looper和当前线程绑定在一起
    mThread = Thread.currentThread();
}


public static final void prepare() { //2,调用prepare()

// 这个判断保证一个线程只能有一个looper
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
// 创建一个looper存放在 ThreadLocal 中， ThreadLocal 的作用就是保证每个线程操作都是自己的对象
    sThreadLocal.set(new Looper()); //3,创建Looper
}


public static final void prepareMainLooper() {// 1, 调用此方法创建 一个Looper

    prepare(); // 2,调用prepare()
    setMainLooper(myLooper());
    if (Process.supportsProcesses()) {
        myLooper().mQueue.mQuitAllowed = false;
    }
}

public static final void loop() { // 4,loop方法

// 获取之前放在 ThreadLocal 中创建的 Looper对象和消息队列
    Looper me = myLooper();
    MessageQueue queue = me.mQueue;
    .....
    while (true) {
    // 代码执行到这里会阻塞。。。 这时候跳到 第二大步骤
        Message msg = queue.next(); // might block

        if (msg != null) {
            if (msg.target == null) {
                // No target is a magic identifier for the quit message.
                return;
            }
           ....
            msg.target.dispatchMessage(msg); // 这个msg.target就是handler,用来区分不同的handler。
           ....
        }
    }
}

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

一，首先一个程序的启动时，他的UI线程(也就是主线程)会在main 方法中调用 Looper的静态方法

# ActivityThread.java 主线程中的部分代码

public static final void main(String[] args) {

.....
// 1, 调用此方法创建 一个Looper
    Looper.prepareMainLooper();

    if (sMainThreadHandler == null) {
        sMainThreadHandler = new Handler();
    }

    ActivityThread thread = new ActivityThread();
    thread.attach(false);
.....
// 4，调用此死循环方法不断的从消息队列中读取消息。
    Looper.loop();

}

二，关于handler，搞清楚前面的Looper 后 再来看看handler是怎么工作的
当我们在activity中创建handler写下下面代码时。
private Handler handler = new Handler() {

    @Override
    public void handleMessage(Message msg) {}

}

来看看他的构造函数
public Handler() {
….
// 这里又调用到了Looper.myLooper()方法，这里得到了UI线程之前创建的Looper。
mLooper = Looper.myLooper();
….
// 此处获得UI线程创建的消息队列
mQueue = mLooper.mQueue;
mCallback = null;
}

可以看到通过Handler() 构造函数 ，新建的handler对象和Looper对象，消息队列绑定在一起了。

总结 一，二 两大步骤可以知道 一个线程里面只有一个looper 和messagequeue，我们有时在activity中却可以创建多个handler的对象发送

消息，那么looper是如何识别不同的handler对象呢，最后跳到第三大步，发送message。

三，我们一般都会开启一个子线程进行一些耗时操作，然后在子线程中发送消息到主线程，主线程在执行更新ui的操作。
当我们使用handler.sendMessage(msg)时，看看handler的源码

public void handleMessage(Message msg) {

}

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

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

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    boolean sent = false;
    // 得到消息队列
    MessageQueue queue = mQueue;
    if (queue != null) {
        // 将当前发送message的对象赋值给msg.target属性，这个属性就是用来区分不同的handler
        msg.target = this;
        // 调用messagequeue的方法
        sent = queue.enqueueMessage(msg, uptimeMillis);
    } else {
        RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
    }
    return sent;
}

可以看到 最后调用sendMessageAtTime()这个方法，再来看看这个方法
得到消息队列
MessageQueue queue = mQueue;
if (queue != null) {
// 将当前发送message的对象赋值给msg.target属性，这个属性就是用来区分不同的handler
msg.target = this;
// 调用messagequeue的方法，
sent = queue.enqueueMessage(msg, uptimeMillis);
最后调用queue.enqueueMessage()方法，将消息添加到消息队列

来看看 MessageQueue.enqueueMessage 代码

final boolean enqueueMessage(Message msg, long when) {
    ...
        Message p = mMessages;
        if (p == null || when == 0 || when < p.when) {
            // 当前发送的message需要马上被处理调，needWake唤醒状态置true
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked; // new head, might need to wake up
        } else {
            // 当前发送的message被排队到其他message的后面，needWake唤醒状态置false
            Message prev = null;
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
            msg.next = prev.next;
            prev.next = msg;
            needWake = false; // still waiting on head, no need to wake up
        }
    }
    // 是否唤醒主线程
    if (needWake) {
        nativeWake(mPtr);
    }
    return true;

}

当handler.sendMessage(msg)完成后，之前的UI线程的loop方法中 Message msg = queue.next()就不会再阻塞了，会依次执行下去
当执行到 msg.target.dispatchMessage(msg);方法时。可以看到hanlder源码最终执行的是 handleMessage()。而我们新建的handler 又重

写了这个方法。从而在主线程进行一些ui操作。

小结下，总的来说就是ui线程会在程序启动时，创建looper和消息队列，然后调用Looper的静态方法 loop(),这个方法中 message msg =

queue.next();//如果里面没有消息就会阻塞。如果Handler在主线程中创建，Looper会在死循环里等待取消息，1、没取到，就阻塞，2、一

旦被子线程唤醒，取到消息，就把Message交给Handler处理。子线程用Handler去发送消息，拿写入描述符去写消息，唤醒主线程。