Handler消息机制源码解析

1.

Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
    sMainThreadHandler = thread.getHandler();
}
if (false) {
    Looper.myLooper().setMessageLogging(new
            LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();

/************************************************/

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

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

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

消息队列和当前线程就绑定在一起了，继续进行无限玄幻，阻塞队列，取出消息，响应消息

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;

    // Make sure the identity of this thread is that of the local process,
    // and keep track of what that identity token actually is.
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();
    for (;;) {
        Message msg = queue.next(); // might block

if (msg == null) {
    // No message indicates that the message queue is quitting.
    return;
}

msg.target.dispatchMessage(msg);

}

 

 

2. 例子:

Acitivity中实例化Handler

private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        int signal = msg.arg1;
        switch (signal) {
            case 0:
                progressView.setProgress(0);
                break;
        }
    }
};

点击

case R.id.btn_enen:
    Message message = new Message();
    message.arg1 = 0;
    mHandler.sendMessage(message);
    break;

在handler构造函数中，获取到和当前线程绑定的looper，也就是主线程的looper对象，threadlocal就是和当前线程绑定数据的工具，是与线程对应的，不同线程绑定同一个变量，只影响在当前线程的值，当前activity的handler就获得了主线程的looper对象，接下来就可以用handler发送消息了，

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 static Looper myLooper() {
    return sThreadLocal.get();
}

发送消息，就是让消息进入主线程的消息队列中，有一部就是给当前handler设置给message的target变量

Handler

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

设置了target的handler以后，在looper.loop无限循环中，就会调用dispatchMessage()

msg.target.dispatchMessage(msg);

在dispatchMessage function调用被activity的handler复写的handleMessage(),就完成了通信，

Handler

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

有个地方就是如果设置了message的回调，就会执行message的回调，不会执行handleMessage(),如果没有设置message的回调，但设置了handler的callback，就会优先执行handler的callback,看返回值，如果返回true，就代表已经处理了，如果返回false，就继续执行handler的handlMessage()

private Handler mHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        return false;
    }
}) {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        int signal = msg.arg1;
        switch (signal) {
            case 0:
                progressView.setProgress(0);
                break;
        }
    }
};