MessageQueue是怎么保证线程安全的

MessageQueue 在 Android 中负责存储并管理消息 (Message) 对象，它与 Looper 和 Handler 协同工作，保证消息在多线程环境中的安全传递和处理。MessageQueue 使用了一系列同步机制来保证线程安全。以下是 MessageQueue 保证线程安全的主要方法：

1. 使用同步块

MessageQueue 使用同步块 (synchronized) 来保护对队列的访问，确保只有一个线程可以同时访问消息队列。以下是 MessageQueue 中关键方法的简化代码示例：

// 将消息入队
boolean enqueueMessage(Message msg, long when) {
    synchronized (this) {
        // 处理插入消息的逻辑
        // 保证队列操作的线程安全
    }
}

// 从队列中取出消息
Message next() {
    synchronized (this) {
        // 处理取出消息的逻辑
        // 保证队列操作的线程安全
    }
}

2. 消息插入与取出

当一个线程将消息插入到 MessageQueue 中时，它会调用 enqueueMessage 方法，该方法使用同步块来保证消息的插入操作是线程安全的。同样，当 Looper 线程从 MessageQueue 中取出消息时，会调用 next 方法，该方法也使用同步块来保证消息的取出操作是线程安全的。

3. 使用条件变量

MessageQueue 还使用了条件变量（Condition Variable）来管理消息的等待和唤醒。这样可以让 Looper 线程在没有消息时进入等待状态，并在有新消息插入时被唤醒。

Message next() {
    int nextPollTimeoutMillis = 0;
    for (;;) {
        // other codes

        synchronized (this) {
            // 如果没有消息，进入等待状态
            if (mMessages == null) {
                try {
                    wait(nextPollTimeoutMillis);
                } catch (InterruptedException e) {
                    // 忽略中断
                }
            }
            // other codes
        }
    }
}

在 enqueueMessage 方法中，如果新消息的到达时间比当前消息早，或者队列为空，MessageQueue 会唤醒等待的线程：

boolean enqueueMessage(Message msg, long when) {
    synchronized (this) {
        // 插入消息的逻辑

        // 唤醒等待的线程
        notify();
    }
}

4. 主线程与工作线程的交互

主线程（UI线程）通常运行一个 Looper，并通过 Handler 与工作线程通信。Handler 将消息插入到主线程的 MessageQueue 中，而主线程的 Looper 会从 MessageQueue 中取出并处理这些消息。

5. 示例代码

以下是 MessageQueue 保证线程安全的示例代码：

public class SafeMessageQueue {
    private Message mMessages;

    public synchronized boolean enqueueMessage(Message msg, long when) {
        // 处理插入消息的逻辑
        msg.when = when;
        Message p = mMessages;
        if (p == null || when == 0 || when < p.when) {
            msg.next = p;
            mMessages = msg;
            notify(); // 唤醒等待的线程
            return true;
        }
        Message prev;
        for (;;) {
            prev = p;
            p = p.next;
            if (p == null || when < p.when) {
                break;
            }
        }
        msg.next = p; // 插入消息
        prev.next = msg;
        return true;
    }

    public synchronized Message next() {
        // 处理取出消息的逻辑
        for (;;) {
            if (mMessages == null) {
                try {
                    wait(); // 没有消息时等待
                } catch (InterruptedException e) {
                    // 忽略中断
                }
            }
            // 获取消息并返回
            Message msg = mMessages;
            mMessages = msg.next;
            return msg;
        }
    }
}

结论

通过使用同步块、条件变量和线程间的正确交互，MessageQueue 能够在多线程环境中安全地管理消息，从而保证线程安全性。这些机制确保了在不同线程间传递和处理消息时，消息队列的状态不会出现不一致或竞争条件。