Handler源码分析

 Handler     h =new Handler(){
            @Override public void handleMessage(Message msg) {
                super.handleMessage(msg);
            }
        };
        Message message = new Message();
        message.obj="xxx";
        h.sendMessage(message);

public Handler() {
      this(null, false);
 }

public Handler(Callback callback, boolean async) {
       if (FIND_POTENTIAL_LEAKS) {
          final Class<? extends Handler> klass = getClass();
           if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
             Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                klass.getCanonicalName());
       }
     }
   //这里开始获取looper,由于我们的looper在主线程已经给我初始化了一个，所以如果我们在主线创建handler这个looper就是ManLooer
    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 Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
      mQueue = looper.mQueue;
       mCallback = callback;
       mAsynchronous = async;
  }

 public final boolean sendMessage(Message msg)
   {
       return sendMessageDelayed(msg, 0);
   }

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

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
     msg.target = this;
    if (mAsynchronous) {
       msg.setAsynchronous(true);
     }
      return queue.enqueueMessage(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;
   }

 public static void main(String[] args) {

        Looper.prepareMainLooper();

      ActivityThread thread = new ActivityThread();
       thread.attach(false);

       if (sMainThreadHandler == null) {
           sMainThreadHandler = thread.getHandler();
     }

       if (false) {
           Looper.myLooper().setMessageLogging(new
                  LogPrinter(Log.DEBUG, "ActivityThread"));
       }

        // End of event ActivityThreadMain.
       Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();

       throw new RuntimeException("Main thread loop unexpectedly exited");
   }
}

 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 dispatchMessage(Message msg) {
        if (msg.callback != null) {
           handleCallback(msg);
       } else {
            if (mCallback != null) {
           if (mCallback.handleMessage(msg)) {
                  return;
             }
        }
           handleMessage(msg);
      }
   }