Handler消息机制

Handler消息机制.

Message对象的创建:

Message msg = new Message();

Message msg = Message.obtain();

Handler对象, 初始化了两个对象:Looper, MessageQueue. 初始化完毕后, 其中主线程的Looper对象已经开始轮询, 循环的取消息, 但现在没有消息, 主线程处于睡眠. 代码如下:

public Handler() {
    ...

	// 得到一个主线程的Looper对象
    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 = null;
}

主线程Looper的初始化, 在ActivityThread中的main函数中, 代码如下:

public static final void main(String[] args) {
    ...
	// 在主线程中调用了prepareMainLooper方法, 此方法中创建了一个Looper对象, 此Looper对象就是主线程中的Looper对象.
    Looper.prepareMainLooper();
    
	...

    Looper.loop();

	...
}

Looper类中的loop方法, 其中有一个死循环. 是否会阻塞主线程? 设计概念管道(Pipe), 管道可以实现进程间通信, 原理: 管道其实是Linux系统的一种通信方式, 实现方式主要是一个特殊的文件来实现. 此文件有两个描述符(对文件进行操作的一个句柄(引用)), 一个是读取的, 一个是写入的.

应用场景: 主线程拿着读取的描述符在等待读取, 这时子线程拿着写入的操作符进行写入, 当写入时会唤醒主线程, 主线程开始读取子线程写入的内容. 执行循环的代码.

Handler的场景: 主线程在while循环中, 取消息: 1. 取到消息后, 分发消息. 2. 没取到消息, 阻塞主线程, 主线程睡眠了. 当子线程sendMessage发送消息时, 这时用写入的描述符写入到管道中, 主线程被唤醒, 继续跑它的循环, 取消息.

public static final void loop() {
    Looper me = myLooper();
    MessageQueue queue = me.mQueue;
    while (true) {
        Message msg = queue.next(); // might block
        ...
    }
}

使用Handler对象发送消息, sendMessage方法如下:

    public final boolean sendMessage(Message msg) {
		// 1. 转调
        return sendMessageDelayed(msg, 0);
    }

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

	public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
			// 3. 把当前Handler对象赋值给Message中的target对象.
            msg.target = this;
			// 4. 把消息传递给消息队列存起来.
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

	// 此方法是把传递进来的消息按照先后顺序或者时间来进行排序, 并且存起来.
	final boolean enqueueMessage(Message msg, long when) {
        ...

        msg.when = when;
        //Log.d("MessageQueue", "Enqueing: " + msg);
        Message p = mMessages;
        if (p == null || when == 0 || when < p.when) {
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked; // new head, might need to wake up
        } else {
            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
        }

		...
    }

主线程会被唤醒, 继续执行while循环, 去消息队列MessageQueue中取消息.

public static final void loop() {
    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;
            }
            if (me.mLogging!= null) me.mLogging.println(
                    ">>>>> Dispatching to " + msg.target + " "
                    + msg.callback + ": " + msg.what
                    );

			// 因为Message中的target对象就是Handler对象, 这里其实调用的是Handler中的dispatchMessage方法.
            msg.target.dispatchMessage(msg);
            if (me.mLogging!= null) me.mLogging.println(
                    "<<<<< Finished to    " + msg.target + " "
                    + msg.callback);
            msg.recycle();
        }
    }
}

Handler中的dispatchMessage方法, 代码如下:

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
		// 调用了自己的handleMessage方法.
        handleMessage(msg);
    }
}

/**
 * Subclasses must implement this to receive messages.
 * 子类必须实现此方法去接收消息.
 */
public void handleMessage(Message msg) {
}

用户在使用Handler时, 必须实现handleMessage方法来处理消息, 代码如下:

Handler handler = new Handler() {

	public void handleMessage(Message msg) {
		// 根据来的消息的标识, 处理相应的业务.
		...
	}
}