在Android开发中，Looper是Android消息处理机制的核心，它负责将消息传递到对应的线程进行处理。理解Looper的工作原理对于掌握Android线程通信技巧至关重要。本文将深入解析Looper的源码，帮助你轻松掌握这一关键机制。
Looper简介
Looper是Android消息循环机制的核心，它允许应用程序在多个线程之间进行通信。每个线程通过创建一个Looper对象，然后使用Handler向Looper发送消息。Looper会负责将这些消息放入消息队列中，并在消息到来时调用相应的Handler处理这些消息。
Looper的创建与启动
Looper的创建和启动过程如下：
创建Looper
：在主线程中，通过
Looper.prepare()
方法创建一个Looper对象。在子线程中，需要调用
Looper.prepare()
方法来创建一个Looper对象。
private static final Thread MAIN_THREAD = Thread.currentThread();
private static final Looper MAIN_LOOPER = Looper.getMainLooper();
启动Looper
：通过调用
Looper.loop()
方法启动Looper。在主线程中，
Looper.loop()
会在ActivityThread的run方法中被调用。在子线程中，需要手动调用
Looper.loop()
方法。
private static final Thread THREAD = new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
Looper.loop();
}
});
THREAD.start();
Looper的源码解析
以下是对Looper源码的解析：
public class Looper {
private static final ThreadLocal
@Override
protected Looper initialValue() {
return new Looper();
}
};
private static volatile Looper sMainLooper;
private final MessageQueue mQueue;
private final Thread mThread;
private Looper() {
mQueue = new MessageQueue();
mThread = Thread.currentThread();
}
public static void prepare() {
prepare(true);
}
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));
}
public static void loop() {
final Looper me = sThreadLocal.get();
if (me == null) {
throw new RuntimeException(“No Looper; Looper.prepare() must be called on the main thread”);
}
final MessageQueue queue = me.mQueue;
// Looper循环主体
for (;;) {
Message msg = queue.next(); // 阻塞，直到获取到消息
if (msg == null) {
throw new RuntimeException(“Message queue is empty”);
}
// 处理消息
traceBegin(TRACE_MESSAGE_DELIVERY);
try {
dispatchMessage(msg);
} finally {
traceEnd(TRACE_MESSAGE_DELIVERY);
}
}
}
public static Looper myLooper() {
return sThreadLocal.get();
}
public static boolean isMainLooper() {
return sMainLooper == myLooper();
}
public void quit() {
mQueue.quit();
}
public void quitSafely() {
mQueue.quitSafely();
}
// 省略其他方法…
}
从上述源码可以看出，Looper的工作原理如下：
Looper.prepare()
：创建Looper对象，并将当前线程与Looper关联。
Looper.loop()
：启动Looper循环，等待消息到来。当有消息到来时，调用
queue.next()
获取消息，然后通过
dispatchMessage()
方法处理消息。
queue.next()
：阻塞，直到获取到消息。
dispatchMessage()
：根据消息类型，调用相应的Handler处理消息。
Handler与Looper的关系
Handler负责将消息发送给Looper，并将消息传递给相应的线程进行处理。以下是对Handler与Looper关系的解析：
public class Handler {
private final Looper mLooper;
private final MessageQueue mQueue;
private final Callback mCallback;
public Handler() {
this(Looper.getMainLooper());
}
public Handler(Looper looper) {
this(looper, null);
}
public Handler(Looper looper, Callback callback) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
}
public void handleMessage(Message msg) {
if (mCallback != null) {
mCallback.handleMessage(msg);
}
}
// 省略其他方法…
}
从上述源码可以看出，Handler与Looper的关系如下：
Handler的构造函数中，传入Looper对象，并将当前线程与Looper关联。
Handler的
handleMessage()
方法用于处理消息，该方法由Looper调用。
Handler可以通过
post()
和
sendMessage()
方法发送消息给Looper。
总结
通过本文的解析，相信你已经对Android Looper的工作原理有了深入的了解。掌握Looper的工作原理对于Android开发至关重要，它可以帮助你更好地理解Android的消息处理机制，并轻松掌握线程通信技巧。希望本文能对你有所帮助。