Android源码分析之Message

private Runnable mRunnable = new Runnable() {
    @Override
    public void run() {
        // do something...
        removeCallbacks(this);
    }
};

postDelayed(mRunnable, SOME_DELAY_IN_MILLIMS);

 1 /**
 2      * <p>Removes the specified Runnable from the message queue.</p>
 3      *
 4      * @param action The Runnable to remove from the message handling queue
 5      *
 6      * @return true if this view could ask the Handler to remove the Runnable,
 7      *         false otherwise. When the returned value is true, the Runnable
 8      *         may or may not have been actually removed from the message queue
 9      *         (for instance, if the Runnable was not in the queue already.)
10      *
11      * @see #post
12      * @see #postDelayed
13      * @see #postOnAnimation
14      * @see #postOnAnimationDelayed
15      */
16     public boolean removeCallbacks(Runnable action) {
17         if (action != null) {
18             final AttachInfo attachInfo = mAttachInfo;
19             if (attachInfo != null) {
20                 attachInfo.mHandler.removeCallbacks(action);
21                 attachInfo.mViewRootImpl.mChoreographer.removeCallbacks(
22                         Choreographer.CALLBACK_ANIMATION, action, null);
23             } else {
24                 // Assume that post will succeed later
25                 ViewRootImpl.getRunQueue().removeCallbacks(action);
26             }
27         }
28         return true;
29     }

1 public boolean postDelayed(Runnable action, long delayMillis) {
2         final AttachInfo attachInfo = mAttachInfo;
3         if (attachInfo != null) {
4             return attachInfo.mHandler.postDelayed(action, delayMillis);
5         }
6         // Assume that post will succeed later
7         ViewRootImpl.getRunQueue().postDelayed(action, delayMillis);
8         return true;
9     }

 1  /*package*/ Handler target;
 2 
 3     /*package*/ Runnable callback;
 4 
 5     // sometimes we store linked lists of these things
 6     /*package*/ Message next;
 7 
 8     private static final Object sPoolSync = new Object();
 9     private static Message sPool;
10     private static int sPoolSize = 0;
11 
12     private static final int MAX_POOL_SIZE = 50;

 1 public void dispatchMessage(Message msg) {
 2         if (msg.callback != null) {
 3             handleCallback(msg);
 4         } else {
 5             if (mCallback != null) {
 6                 if (mCallback.handleMessage(msg)) {
 7                     return;
 8                 }
 9             }
10             handleMessage(msg);
11         }
12     }

 1 /**
 2      * Return a new Message instance from the global pool. Allows us to
 3      * avoid allocating new objects in many cases.
 4      */
 5     public static Message obtain() {
 6         synchronized (sPoolSync) {
 7             if (sPool != null) {
 8                 Message m = sPool;
 9                 sPool = m.next;
10                 m.next = null;
11                 sPoolSize--;
12                 return m;
13             }
14         }
15         return new Message();
16     }
17 
18 /**
19      * Return a Message instance to the global pool.  You MUST NOT touch
20      * the Message after calling this function -- it has effectively been
21      * freed.
22      */
23     public void recycle() {
24         clearForRecycle();
25 
26         synchronized (sPoolSync) {
27             if (sPoolSize < MAX_POOL_SIZE) {
28                 next = sPool;
29                 sPool = this;
30                 sPoolSize++;
31             }
32         }
33     }