//可以看到我们的Looper是存放在线程独有的ThreadLocal进行隔离的
//也就是每个线程独有一份Looper
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
//系统帮我们实现的主线程的Looper对象
private static Looper sMainLooper;
//每一个Looper都有自己的MessageQueue消息队列
final MessageQueue mQueue;
final Thread mThread;
* class LooperThread extends Thread {
* public Handler mHandler;
*
* public void run() {
* Looper.prepare();
*
* mHandler = new Handler() {
* public void handleMessage(Message msg) {
* // process incoming messages here
* }
* };
*
* Looper.loop();
* }
* }
这个是Looper开篇的使用示例
我们在使用Handler机制的时候需要创建一个Looper对象利用Looper里面的MessageQueue消息队列
来存放我们发送的Message消息Message消息里面存有我们发送的数据、延迟时间、回调方法等。
这样在looper进行轮询消息队列的时候就能够将里面的Message交给对应的Handler去处理。
在子线程中：
Looper.prepare();是用来创建一个Looper的
源码：
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
//从ThreadLocal去拿我们的Looper 如果已经存在了就抛出异常
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//否则就创建一个looper对象并放在ThreadLocal中存储
sThreadLocal.set(new Looper(quitAllowed));
}
new Looper(quitAllowed) 源码：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到 在创建Looper的时候也会创建一个MessageQueue消息队列
//主线程的Looper创建----系统会在ActivityThread的main()方法里面调用这个方法进行创建的
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
* 源码分析：main（）
**/
public static void main(String[] args) {
Looper.prepareMainLooper();
// 1. 为主线程创建1个Looper对象，同时生成1个消息队列对象（MessageQueue）
// 方法逻辑类似Looper.prepare()
// 注：prepare()：为子线程中创建1个Looper对象
ActivityThread thread = new ActivityThread();
// 2. 创建主线程
Looper.loop();
// 3. 自动开启 消息循环 ->>下面将详细分析
}
loop() 源码
public static void loop() {
//获取当前线程的Looper对象
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();
// Allow overriding a threshold with a system prop. e.g.
// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
final int thresholdOverride =
SystemProperties.getInt("log.looper."
+ Process.myUid() + "."
+ Thread.currentThread().getName()
+ ".slow", 0);
boolean slowDeliveryDetected = false;
for (;;) {
// 从MessageqQueue里面去拿消息 这个过程会随着message取完后阻塞
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
if (thresholdOverride > 0) {
slowDispatchThresholdMs = thresholdOverride;
slowDeliveryThresholdMs = thresholdOverride;
}
final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
final boolean needStartTime = logSlowDelivery || logSlowDispatch;
final boolean needEndTime = logSlowDispatch;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
final long dispatchEnd;
try {
//取出的消息会交给对应的Handler去处理
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logSlowDelivery) {
if (slowDeliveryDetected) {
if ((dispatchStart - msg.when) <= 10) {
Slog.w(TAG, "Drained");
slowDeliveryDetected = false;
}
} else {
if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
msg)) {
// Once we write a slow delivery log, suppress until the queue drains.
slowDeliveryDetected = true;
}
}
}
if (logSlowDispatch) {
showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
//释放这个消息 放入消息缓冲池---单链表的头部
msg.recycleUnchecked();
}
}
总结：Looper实际是利用ThreadLocal和线程进行绑定的，通过内部维护的一个消息队列来存储格格Handler发送过来的Message
实现线程间通信的