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()) && 
       (klass.getModifiers() &Modifier.STATIC) == 0) { 
     Log.w(TAG, "The followingHandler class should be static or leaks might occur: " + 
       klass.getCanonicalName()); 
   } 
 } 
 mLooper = Looper.myLooper(); 
 if (mLooper == null) { 
   throw new RuntimeException( 
     "Can't create handler insidethread that has not called Looper.prepare()"); 
 } 
 mQueue = mLooper.mQueue; 
 mCallback = null; 
}

public static finalLooper myLooper() { 
 return (Looper)sThreadLocal.get(); 
}

public static final void prepare() { 
  if (sThreadLocal.get() != null) { 
    throw new RuntimeException("Only one Looper may be created per thread"); 
  } 
  sThreadLocal.set(new Looper()); 
}

Message message = new Message();  
mHandler.sendMessage(message);

public final Message obtainMessage(int what, int arg1, int arg2, Object obj){ 
  return Message.obtain(this, what, arg1,arg2, obj); 
}

public static Message obtain(Handler h, int what, int arg1, int arg2, Object obj) { 
   Message m = obtain(); 
   m.target = h; 
   m.what = what; 
   m.arg1 = arg1; 
   m.arg2 = arg2; 
   m.obj = obj; 
   return m; 
}

public static Message obtain() { 
   synchronized (sPoolSync) { 
     if (sPool != null) { 
       Message m = sPool; 
       sPool = m.next; 
       m.next = null; 
       m.flags = 0; // clear in-useflag 
       sPoolSize--; 
       return m; 
     } 
   } 
   return new Message(); 
 }

public int arg1

public int arg2

public Object obj

public int what

public Handler target

public final boolean sendMessage(Message msg){
  return sendMessageDelayed(msg, 0);//直接调用sendMessageDelayed()，只是没有时间延迟
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
  if (delayMillis < 0) {
    delayMillis = 0;
  } 
  return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);//调用sendMessageAtTime，当前时间加上延迟时间。
}

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);//调用enqueueMessage,附上消息队列和时间
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
 msg.target = this;  
 if (mAsynchronous) {    
  msg.setAsynchronous(true);  
 }  
 return queue.enqueueMessage(msg, uptimeMillis);//最后调用队列的插入消息方法，只是插入的时间有制定。
}

public final boolean sendEmptyMessage(int what){
  return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) { 
Message msg = Message.obtain(); 
msg.what = what; 
return sendMessageDelayed(msg, delayMillis); 
}

handler.post(new Runnable() { 
      @Override 
      public void run() { 
        //这里就可以进行UI操作。
      } 
    });

public final boolean post(Runnable r){ 
  return sendMessageDelayed(getPostMessage(r), 0); 
}

private final Message getPostMessage(Runnable r) {
  Message m = Message.obtain();
  m.callback = r;
  return m;
}

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

private final void handleCallback(Message message) {
  message.callback.run();
}

public boolean post(Runnable action) {
  Handler handler;
  if (mAttachInfo != null) {
    handler = mAttachInfo.mHandler;
  } else {
    ViewRoot.getRunQueue().post(action);
    return true;
  }
  return handler.post(action);
}

public final void runOnUiThread(Runnable action) { 
  if (Thread.currentThread() != mUiThread) { 
    mHandler.post(action); 
  } else { 
    action.run(); 
  } 
}