Android消息队列和Looper

publicfinalboolean sendMessage(Message msg) 
{ 
return sendMessageDelayed(msg, 0); 
} 
publicfinalboolean sendMessageDelayed(Message msg, long delayMillis) 
{ 
if (delayMillis < span>0) { 
delayMillis = 0; 
} 
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); 
} 
publicboolean sendMessageAtTime(Message msg, long uptimeMillis) { 
MessageQueue queue = mQueue; 
if (queue == null) { 
RuntimeException e = new RuntimeException( 
this + " sendMessageAtTime() called with no mQueue"); 
Log.w("Looper", e.getMessage(), e); 
returnfalse; 
} 
return enqueueMessage(queue, msg, uptimeMillis); 
} 
privateboolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { 
msg.target = this; 
if (mAsynchronous) { 
msg.setAsynchronous(true); 
} 
//这里msg被加入消息队列queue
return queue.enqueueMessage(msg, uptimeMillis); 
} 

publicstaticvoid loop()
 { 
    final Looper me = myLooper(); 
    if (me == null) 
    { 
    thrownew RuntimeException("No Looper; Looper.prepare()     wasn‘t called on this thread."); 
    } 
    //从Looper中取出消息队列
    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(); 
    finallong ident = Binder.clearCallingIdentity(); 
//死循环，循环的取消息，没有新消息就会阻塞
    for (;;) 
    { 
        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
        Printer logging = me.mLogging; 
        if (logging != null) 
{ 
logging.println("<<<<< Dispatching to " + msg.target + " " + 
msg.callback + ": " + msg.what); 
} 
//将消息交给target处理，这个target就是Handler类型
msg.target.dispatchMessage(msg); 
if (logging != null) { 
logging.println("< Finishedtospan> + msg.target + " " + msg.callback); 
} 
// Make sure that during the course of dispatching the
// identity of the thread wasn‘t corrupted.
finallong 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.recycle(); 
} 
}                        

/**
* Subclasses must implement this to receive messages.
*/
publicvoid handleMessage(Message msg) { 
} 
/**
* Handle system messages here.
*/
publicvoid dispatchMessage(Message msg) { 
if (msg.callback != null) { 
//这个方法很简单，直接调用msg.callback.run();
handleCallback(msg); 
} else { 
//如果我们设置了callback会由callback来处理消息
if (mCallback != null) { 
if (mCallback.handleMessage(msg)) { 
return; 
} 
} 
//否则消息就由这里来处理，这是我们最常用的处理方式
handleMessage(msg); 
} 
} 

/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
*
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
publicinterface Callback { 
publicboolean handleMessage(Message msg); 
} 
final Callback mCallback;

@Override
publicvoid run() { 
mTid = Process.myTid(); 
Looper.prepare(); 
synchronized (this) { 
mLooper = Looper.myLooper(); 
notifyAll(); 
} 
Process.setThreadPriority(mPriority); 
onLooperPrepared(); 
Looper.loop(); 
mTid = -1; 
} 

publicvoid onCreate() { 
// TODO: It would be nice to have an option to hold a partial wakelock
// during processing, and to have a static startService(Context, Intent)
// method that would launch the service & hand off a wakelock.
super.onCreate(); 
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]"); 
thread.start(); 
mServiceLooper = thread.getLooper(); 
mServiceHandler = new ServiceHandler(mServiceLooper); 
} 

public Handler(Callback callback, boolean async) { 
if (FIND_POTENTIAL_LEAKS) { 
final Class< span>extends Handler< klass = getClass(); 
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && 
(klass.getModifiers() & Modifier.STATIC) == 0) { 
Log.w(TAG, "The following Handler class should be static or leaks might occur: " + 
klass.getCanonicalName()); 
} 
} 
//获取当前线程的Looper
mLooper = Looper.myLooper(); 
//报错的根本原因是：当前线程没有Looper
if (mLooper == null) { 
thrownew RuntimeException( 
"Can‘t create handler inside thread that has not called Looper.prepare()"); 
} 
mQueue = mLooper.mQueue; 
mCallback = callback; 
mAsynchronous = async; 
}