1、Message相关方法

1-1、Message相关成员变量

  • 每个 Message 都持有 Handler 实例。如果 Handler 持有Activity的引用，Activity onDestroy 后 Message 却仍然在队列中，因为 Handler 与Activity的强关联，会造成 Activity 无法被 GC 回收，导致内存泄露。 因此在Activity onDestroy 时，与Activity关联的Handler应清除它的队列由Activity产生的任务，避免内存泄露

    1.   /**
    2.    * 储存消息数据
    3.    */
    4.   public int what;
    5.   public int arg1;
    6.   public int arg2;
    7.   public Object obj;
    9.   /**
    10.    * 每个消息持有Handler实例
    11.    */
    12.   Handler target;
    14.   /**
    15.    * 消息自带的callback
    16.    */
    17.   Runnable callback;
    19.   /**
    20.    * 下一个消息，所有消息组成一个链表
    21.    */
    22.   android.os.Message next;

    1-2、回收消息

    1.   /**
    2.    * 释放Message避免引用Handler导致内存泄漏
    3.    */
    4.   public void recycle() {
    5.       if (isInUse()) {
    6.           if (gCheckRecycle) {
    7.               throw new IllegalStateException("This message cannot be recycled because it "
    8.                       + "is still in use.");
    9.           }
    10.           return;
    11.       }
    12.       recycleUnchecked();
    13.   }
    15.   void recycleUnchecked() {
    16.       // Mark the message as in use while it remains in the recycled object pool.
    17.       // Clear out all other details.
    18.       flags = FLAG_IN_USE;
    19.       what = 0;
    20.       arg1 = 0;
    21.       arg2 = 0;
    22.       obj = null;
    23.       replyTo = null;
    24.       sendingUid = UID_NONE;
    25.       workSourceUid = UID_NONE;
    26.       when = 0;
    27.       target = null;
    28.       callback = null;
    29.       data = null;
    31.       synchronized (sPoolSync) {
    32.           if (sPoolSize < MAX_POOL_SIZE) {
    33.               next = sPool;
    34.               sPool = this;
    35.               sPoolSize++;
    36.           }
    37.       }
    38.   }

    1-3、创建消息

  • 获取实例最好的办法是调用Message.obtain()或Handler.obtainMessage()。这样可以从他们的可回收对象池中获取到消息实例

    1.   /**
    2.    * 从回收对象池中获取一个消息实例
    3.    * @return
    4.    */
    5.   public static android.os.Message obtain() {
    6.       synchronized (sPoolSync) {
    7.           if (sPool != null) {
    8.               android.os.Message m = sPool;
    9.               sPool = m.next;
    10.               m.next = null;
    11.               m.flags = 0; // clear in-use flag
    12.               sPoolSize--;
    13.               return m;
    14.           }
    15.       }
    16.       return new android.os.Message();
    17.   }
    19.   public static android.os.Message obtain(Handler h) {
    20.       android.os.Message m = obtain();
    21.       m.target = h;
    23.       return m;
    24.   }
    26.   public static android.os.Message obtain(Handler h, Runnable callback) {
    27.       android.os.Message m = obtain();
    28.       m.target = h;
    29.       m.callback = callback;
    31.       return m;
    32.   }

    1-4、发送消息

  • Message自己也有发送消息的方法，但其实还是调用了Handler的发送消息方法

    1.   /**
    2.    * 发送消息 target其实就是Handler
    3.    */
    4.   public void sendToTarget() {
    5.       target.sendMessage(this);
    6.   }

    2、Message简化源码

    ``` public final class Message implements Parcelable {

    /**

    • 储存消息数据 */ public int what; public int arg1; public int arg2; public Object obj;

      /**

    • 每个消息持有Handler实例 */ Handler target;

      /**

    • 消息自带的callback */ Runnable callback;

      /**

    • 下一个消息，所有消息组成一个链表 */ android.os.Message next;
  1. /**
  2.  * 从回收对象池中获取一个消息实例
  3.  * @return
  4.  */
  5. public static android.os.Message obtain() {
  6.     synchronized (sPoolSync) {
  7.         if (sPool != null) {
  8.             android.os.Message m = sPool;
  9.             sPool = m.next;
  10.             m.next = null;
  11.             m.flags = 0; // clear in-use flag
  12.             sPoolSize--;
  13.             return m;
  14.         }
  15.     }
  16.     return new android.os.Message();
  17. }
  19. public static android.os.Message obtain(Handler h) {
  20.     android.os.Message m = obtain();
  21.     m.target = h;
  23.     return m;
  24. }
  26. public static android.os.Message obtain(Handler h, Runnable callback) {
  27.     android.os.Message m = obtain();
  28.     m.target = h;
  29.     m.callback = callback;
  31.     return m;
  32. }
  34. /**
  35.  * 释放Message避免引用Handler导致内存泄漏
  36.  */
  37. public void recycle() {
  38.     if (isInUse()) {
  39.         if (gCheckRecycle) {
  40.             throw new IllegalStateException("This message cannot be recycled because it "
  41.                     + "is still in use.");
  42.         }
  43.         return;
  44.     }
  45.     recycleUnchecked();
  46. }
  48. void recycleUnchecked() {
  49.     // Mark the message as in use while it remains in the recycled object pool.
  50.     // Clear out all other details.
  51.     flags = FLAG_IN_USE;
  52.     what = 0;
  53.     arg1 = 0;
  54.     arg2 = 0;
  55.     obj = null;
  56.     replyTo = null;
  57.     sendingUid = UID_NONE;
  58.     workSourceUid = UID_NONE;
  59.     when = 0;
  60.     target = null;
  61.     callback = null;
  62.     data = null;
  64.     synchronized (sPoolSync) {
  65.         if (sPoolSize < MAX_POOL_SIZE) {
  66.             next = sPool;
  67.             sPool = this;
  68.             sPoolSize++;
  69.         }
  70.     }
  71. }
  73. /**
  74.  * 发送消息 target其实就是Handler
  75.  */
  76. public void sendToTarget() {
  77.     target.sendMessage(this);
  78. }

} ```