理解handler

  
     /      * Default constructor associates this handler with the {@link Looper} for the      * current thread.      *      * If this thread does not have a looper, this handler won't be able to receive messages      * so an exception is thrown.      */     public Handler() {         this(null, false);     }     /      * Constructor associates this handler with the {@link Looper} for the      * current thread and takes a callback interface in which you can handle      * messages.      *      * If this thread does not have a looper, this handler won't be able to receive messages      * so an exception is thrown.      *      * @param callback The callback interface in which to handle messages, or null.      /     public Handler(Callback callback) {         this(callback, false);     }     /**      * Use the provided {@link Looper} instead of the default one.      *      * @param looper The looper, must not be null.      /     public Handler(Looper looper) {         this(looper, null, false);     }     /      * Use the provided {@link Looper} instead of the default one and take a callback      * interface in which to handle messages.      *      * @param looper The looper, must not be null.      * @param callback The callback interface in which to handle messages, or null.      */     public Handler(Looper looper, Callback callback) {         this(looper, callback, false);     }     /      * Use the {@link Looper} for the current thread      * and set whether the handler should be asynchronous.      *      * Handlers are synchronous by default unless this constructor is used to make      * one that is strictly asynchronous.      *      * Asynchronous messages represent interrupts or events that do not require global ordering      * with respect to synchronous messages.  Asynchronous messages are not subject to      * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.      *      * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for      * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.      *      * @hide      /     public Handler(boolean async) {         this(null, async);     }     /**      * Use the {@link Looper} for the current thread with the specified callback interface      * and set whether the handler should be asynchronous.      *      * Handlers are synchronous by default unless this constructor is used to make      * one that is strictly asynchronous.      *      * Asynchronous messages represent interrupts or events that do not require global ordering      * with respect to synchronous messages.  Asynchronous messages are not subject to      * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.      *      * @param callback The callback interface in which to handle messages, or null.      * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for      * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.      *      * @hide      /     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;     }     /*      * Use the provided {@link Looper} instead of the default one and take a callback      * interface in which to handle messages.  Also set whether the handler      * should be asynchronous.      *      * Handlers are synchronous by default unless this constructor is used to make      * one that is strictly asynchronous.      *      * Asynchronous messages represent interrupts or events that do not require global ordering      * with respect to synchronous messages.  Asynchronous messages are not subject to      * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.      *      * @param looper The looper, must not be null.      * @param callback The callback interface in which to handle messages, or null.      * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for      * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.      *      * @hide      /     public Handler(Looper looper, Callback callback, boolean async) {         mLooper = looper;         mQueue = looper.mQueue;         mCallback = callback;         mAsynchronous = async;     }     

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

 
 /* Initialize the current thread as a looper.       * This gives you a chance to create handlers that then reference       * this looper, before actually starting the loop. Be sure to call       * {@link #loop()} after calling this method, and end it by calling       * {@link #quit()}.       /     public static void prepare() {         prepare(true);     }     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();     }      

     /*      * 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();         }     }          

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

 public final class Message implements Parcelable {     public int what;     public int arg1;     public int arg2;     public Object obj;     ...     /package/ int flags;     /package/ long when;     /package/ Bundle data;     /package/ Handler target;     /package/ Runnable callback;     /package/ Message next;     private static final Object sPoolSync = new Object();     private static Message sPool;     private static int sPoolSize = 0; }     

         /*          * Return a new Message instance from the global pool. Allows us to          * avoid allocating new objects in many cases.          /         public static Message obtain() {             synchronized (sPoolSync) {                 if (sPool != null) {                     Message m = sPool;                     sPool = m.next;                     m.next = null;                     m.flags = 0; // clear in-use flag                     sPoolSize--;                     return m;                 }             }             return new Message();         }             

     /      * Return a Message instance to the global pool.      * <p>      * You MUST NOT touch the Message after calling this function because it has      * effectively been freed.  It is an error to recycle a message that is currently      * enqueued or that is in the process of being delivered to a Handler.      * </p>      */     public void recycle() {         if (isInUse()) {             if (gCheckRecycle) {                 throw new IllegalStateException("This message cannot be recycled because it "                         + "is still in use.");             }             return;         }         recycleUnchecked();     }     /      * Recycles a Message that may be in-use.      * Used internally by the MessageQueue and Looper when disposing of queued Messages.      */     void recycleUnchecked() {         // Mark the message as in use while it remains in the recycled object pool.         // Clear out all other details.         flags = FLAG_IN_USE;         what = 0;         arg1 = 0;         arg2 = 0;         obj = null;         replyTo = null;         sendingUid = -1;         when = 0;         target = null;         callback = null;         data = null;         synchronized (sPoolSync) {             if (sPoolSize < MAX_POOL_SIZE) {                 next = sPool;                 sPool = this;                 sPoolSize++;             }         }     }     

 public final boolean sendMessage(Message msg) {     return sendMessageDelayed(msg, 0); } ... public final boolean sendMessageDelayed(Message msg, long delayMillis) {     if (delayMillis < 0) {         delayMillis = 0;     }     return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); } ... 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("MessageQueue", e.getMessage(), e);             msg.recycle();             return false;         }         // 1.设置当前msg的状态         msg.markInUse();         msg.when = when;         Message p = mMessages;         boolean needWake;         // 2.检测当前头指针是否为空（队列为空）或者没有设置when 或者设置的when比头指针的when要前         if (p == null || when == 0 || when < p.when) {             // 3. 插入队列头部，并且唤醒线程处理msg             msg.next = p;             mMessages = msg;             needWake = mBlocked;         } else {             //4. 几种情况要唤醒线程处理消息：1）队列是堵塞的 2)barrier，头部结点无target 3）当前msg是堵塞的             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;                 }             }             // 5. 将当前msg插入第一个比其when值大的结点前。             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; }     

 for (;;) {     ...     Message msg = queue.next(); // 3. 堵塞式在message queue中取数据     if (msg == null) {         // No message indicates that the message queue is quitting.         return;     }     ...     msg.target.dispatchMessage(msg); 4. 分发message到指定的target handler     ... }     

 Message next() {     // 1. 判断当前loop是否已经使用过，下文会解释这个mPtr     final long ptr = mPtr;     if (ptr == 0) {         return null;     }     int pendingIdleHandlerCount = -1; // -1 only during first iteration     int nextPollTimeoutMillis = 0;     // 2. 进入死循环，直到获取到合法的msg对象为止。     for (;;) {         if (nextPollTimeoutMillis != 0) {             Binder.flushPendingCommands(); // 这个是什么？         }         // 3. 进入等待，nextPollTimeoutMillis为等待超时值         nativePollOnce(ptr, nextPollTimeoutMillis);         synchronized (this) {             // 4. 获取下一个msg             final long now = SystemClock.uptimeMillis();             Message prevMsg = null;             Message msg = mMessages;             if (msg != null && msg.target == null) {                 // 当前节点为barrier，所以要找到第一个asynchronous节点                 do {                     prevMsg = msg;                     msg = msg.next;                 } while (msg != null && !msg.isAsynchronous());             }             if (msg != null) {                 if (now < msg.when) {                     // 当前队列里最早的节点比当前时间还要晚，所以要进入堵塞状态，超时值为nextPollTimeoutMillis                     nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);                 } else {                     // 删除当前节点，并返回                     mBlocked = false;                     if (prevMsg != null) {                         prevMsg.next = msg.next;                     } else {                         mMessages = msg.next;                     }                     msg.next = null;                     if (false) Log.v("MessageQueue", "Returning message: " + msg);                     return msg;                 }             } else {                 // 头结点指向null                 nextPollTimeoutMillis = -1;             }             // Process the quit message now that all pending messages have been handled.             if (mQuitting) {                 dispose();                 return null;             }             // 5. 如果当前状态为idle（就绪），则进入idle handle的代码块             //    进入idle的情况有：队列为空；队列头元素blocking;             if (pendingIdleHandlerCount < 0                     && (mMessages == null || now < mMessages.when)) {                 pendingIdleHandlerCount = mIdleHandlers.size();             }             if (pendingIdleHandlerCount <= 0) {                 // 6. 本轮唤醒（next被调用）时没处理任何东西，故再次进入等待。                 mBlocked = true;                 continue;             }             if (mPendingIdleHandlers == null) {                 mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];             }             mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);         }         // 在一次next调用中，这个代码块只会执行一次         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 {                 // 如果返回true，则idler被保留，下次next的idle时会被调用。                 keep = idler.queueIdle();             } catch (Throwable t) {                 Log.wtf("MessageQueue", "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 static interface IdleHandler {     boolean queueIdle(); }