Handler 메시지 메커니즘 해석

 public Handler(Callback callback, boolean async) {
     if (FIND_POTENTIAL_LEAKS) {
         final Class 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());
         }
     }

     mLooper = Looper.myLooper();
     if (mLooper == null) {
         throw new RuntimeException(
         "Can't create handler inside thread that has not called Looper.prepare()");
     }
     mQueue = mLooper.mQueue;
     mCallback = callback;
     mAsynchronous = async;
 }

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

  /**
  * Handle system messages here.
  */
 public void dispatchMessage(Message msg) {
     if (msg.callback != null) {
         handleCallback(msg);
     } else {
         if (mCallback != null) {
             if (mCallback.handleMessage(msg)) {
                 return;
             }
         }
         handleMessage(msg);
     }
 }

 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 Looper(boolean quitAllowed) {
         mQueue = new MessageQueue(quitAllowed);
         mThread = Thread.currentThread();
     } 

 /**
  * Return the Looper object associated with the current thread.  Returns
  * null if the calling thread is not associated with a Looper.
  */
 public static @Nullable Looper myLooper() {
     return sThreadLocal.get();
 }

 /**
  * Return the {@link MessageQueue} object associated with the current
  * thread.  This must be called from a thread running a Looper, or a
  * NullPointerException will be thrown.
  */
 public static @NonNull MessageQueue myQueue() {
     return myLooper().mQueue;
 }

 /**
  * Run the message queue in this thread. Be sure to call
  * {@link #quit()} to end the loop.
  */
 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();
     }
 }

 public void set(T value) {
     Thread currentThread = Thread.currentThread();
     Values values = values(currentThread);
     if (values == null) {
         values = initializeValues(currentThread);
     }
         values.put(this, value);
 }

 public T get() {
     // Optimized for the fast path.
     Thread currentThread = Thread.currentThread();
     Values values = values(currentThread);
     if (values != null) {
         Object[] table = values.table;
         int index = hash & values.mask;
         if (this.reference == table[index]) {
             return (T) table[index + 1];
         }
     } else {
         values = initializeValues(currentThread);
     }

     return (T) values.getAfterMiss(this);
 }