Android的消息机制

public boolean 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);  return false; } return enqueueMessage(queue, msg, uptimeMillis); }

boolean enqueueMessage(Message msg, long when) { if (msg.target == null) {  throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse()) {  throw new IllegalStateException(msg + " This message is already in use."); } synchronized (this) {  if (mQuitting) {  IllegalStateException e = new IllegalStateException(   msg.target + " sending message to a Handler on a dead thread");  Log.w(TAG, e.getMessage(), e);  msg.recycle();  return false;  }  msg.markInUse();  msg.when = when;  Message p = mMessages;  boolean needWake;  if (p == null || when == 0 || when < p.when) {  // New head, wake up the event queue if blocked.  msg.next = p;  mMessages = msg;  needWake = mBlocked;  } else {  // Inserted within the middle of the queue. Usually we don't have to wake  // up the event queue unless there is a barrier at the head of the queue  // and the message is the earliest asynchronous message in the queue.  needWake = mBlocked && p.target == null && msg.isAsynchronous();  Message prev;  for (;;) {   prev = p;   p = p.next;   if (p == null || when < p.when) {   break;   }   if (needWake && p.isAsynchronous()) {   needWake = false;   }  }  msg.next = p; // invariant: p == prev.next  prev.next = msg;  }  // We can assume mPtr != 0 because mQuitting is false.  if (needWake) {  nativeWake(mPtr);  } } return true; }

 private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }

new Thread(){ public void run(){ Looper.prepare(); Handler handler = new Handler()； Looper.loop(); }}.start();

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)); }

private ThreadLocal<Boolean> mBooleanThreadLocal = new  ThreadLocal<Boolean>();//mBooleanThreadLocal.set(true);Log.d(TAH,"Threadmain"+mBooleanThreadLocal.get());new Thread("Thread#1"){ public void run(){ mBooleanThreadLocal.set(false); Log.d(TAH,"Thread#1"+mBooleanThreadLocal.get()); }； }.start();new Thread("Thread#2"){ public void run(){ Log.d(TAH,"Thread#2"+mBooleanThreadLocal.get()); }； }.start();

public static void loop() { 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(); 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);  }  msg.target.dispatchMessage(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(); } }

Message next() { // Return here if the message loop has already quit and been disposed. // This can happen if the application tries to restart a looper after quit // which is not supported. final long ptr = mPtr; if (ptr == 0) {  return null; } int pendingIdleHandlerCount = -1; // -1 only during first iteration int nextPollTimeoutMillis = 0; for (;;) {  if (nextPollTimeoutMillis != 0) {  Binder.flushPendingCommands();  }  nativePollOnce(ptr, nextPollTimeoutMillis);  synchronized (this) {  // Try to retrieve the next message. Return if found.  final long now = SystemClock.uptimeMillis();  Message prevMsg = null;  Message msg = mMessages;  if (msg != null && msg.target == null) {   // Stalled by a barrier. Find the next asynchronous message in the queue.   do {   prevMsg = msg;   msg = msg.next;   } while (msg != null && !msg.isAsynchronous());  }  if (msg != null) {   if (now < msg.when) {   // Next message is not ready. Set a timeout to wake up when it is ready.   nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);   } else {   // Got a message.   mBlocked = false;   if (prevMsg != null) {    prevMsg.next = msg.next;   } else {    mMessages = msg.next;   }   msg.next = null;   if (DEBUG) Log.v(TAG, "Returning message: " + msg);   msg.markInUse();   return msg;   }  } else {   // No more messages.   nextPollTimeoutMillis = -1;  }  // Process the quit message now that all pending messages have been handled.  if (mQuitting) {   dispose();   return null;  }  // If first time idle, then get the number of idlers to run.  // Idle handles only run if the queue is empty or if the first message  // in the queue (possibly a barrier) is due to be handled in the future.  if (pendingIdleHandlerCount < 0   && (mMessages == null || now < mMessages.when)) {   pendingIdleHandlerCount = mIdleHandlers.size();  }  if (pendingIdleHandlerCount <= 0) {   // No idle handlers to run. Loop and wait some more.   mBlocked = true;   continue;  }  if (mPendingIdleHandlers == null) {   mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];  }  mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);  }  // Run the idle handlers.  // We only ever reach this code block during the first iteration.  for (int i = 0; i < pendingIdleHandlerCount; i++) {  final IdleHandler idler = mPendingIdleHandlers[i];  mPendingIdleHandlers[i] = null; // release the reference to the handler  boolean keep = false;  try {   keep = idler.queueIdle();  } catch (Throwable t) {   Log.wtf(TAG, "IdleHandler threw exception", t);  }  if (!keep) {   synchronized (this) {   mIdleHandlers.remove(idler);   }  }  }  // Reset the idle handler count to 0 so we do not run them again.  pendingIdleHandlerCount = 0;  // While calling an idle handler, a new message could have been delivered  // so go back and look again for a pending message without waiting.  nextPollTimeoutMillis = 0; } }

public void dispatchMessage(Message msg) { if (msg.callback != null) {  handleCallback(msg); } else {  if (mCallback != null) {  if (mCallback.handleMessage(msg)) {   return;  }  }  handleMessage(msg); } }