Handle源码分析，深入群内了解风骚的Handle机制

Hanlder的使用方式一：

 private static Handler mHandler =  new Handler(){
         public void handleMessage(android.os.Message msg) {
             switch (msg.what) {
             case ONE:

                 break;

             default:
                 break;
             }
         };
     };

Handler的使用方式二：

     public void startHandlerThread(){
         HandlerThread mHandlerThread = new HandlerThread("TestHandler");
         mHandlerThread.start();
         Handler mHandler = new Handler(mHandlerThread.getLooper()){
             @Override
             public void handleMessage(Message msg) {
                 // TODO Auto-generated method stub
                 super.handleMessage(msg);
             }
         };
     }

第二种比较通用，为什么这么说类，原因就是HandlerTrehad是个Thread，在run方法内部已经完成了Looper.prepare()的方法的调用，所以即使在子线程中也不会有任何问题

基本的使用就暂时说这些!!!!!

进入咱们今天的正题，深入裙内分析Handler源码：

 /**
      * Sends a Message containing only the what value.
      *
      * @return Returns true if the message was successfully placed in to the
      *         message queue.  Returns false on failure, usually because the
      *         looper processing the message queue is exiting.
      */
     public final boolean sendEmptyMessage(int what)
     {
         return sendEmptyMessageDelayed(what, 0);
     }

关于sendMessage就暂时拿这个进入问题内部；

Line10：说的很明确，调用delay方法，传入delay事件零毫秒，在跟进一步

  /**
      * Sends a Message containing only the what value, to be delivered
      * after the specified amount of time elapses.
      * @see #sendMessageDelayed(android.os.Message, long)
      *
      * @return Returns true if the message was successfully placed in to the
      *         message queue.  Returns false on failure, usually because the
      *         looper processing the message queue is exiting.
      */
     public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
         Message msg = Message.obtain();
         msg.what = what;
         return sendMessageDelayed(msg, delayMillis);
     }

　　这个方法为每个Handler消息进行封装一个Message对象，然后继续调用delay方法，但是这个方法的参数和之前的不一样，不通点就是接受一个Mesage对象，和一个延迟的时间。

　　Line11：从缓存中读取Mesage对象，如果没有则直接创建；

　　Line12，绑定What，回头再handlerMessage()方法中要用到；充当Swith的case；

　　继续深入：

 public final boolean sendMessageDelayed(Message msg, long delayMillis)
     {
         if (delayMillis < 0) {
             delayMillis = 0;
         }
         return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
     }

　　该出进行了容错处理防止你瞎传值；

　　然后调用方法sendMessageAtTime这里的参数需要说明下：为什么SystemClock.uptimeMillis() + delayMillis这块的意思是加当当前系统时间，其实意思很明显如果你的延迟时间是一秒，那么这个一一秒的起始点，自然就是从当前算起，不然你仅仅说一秒，那么从什么时候开始那，这里就是这个意思了！！！

　　来继续看方法sendMessageAtTime

 public boolean sendMessageAtTime(Message msg, long uptimeMillis)
     {
         boolean sent = false;
         MessageQueue queue = mQueue;
         if (queue != null) {
             msg.target = this;
             sent = queue.enqueueMessage(msg, uptimeMillis);
         }
         else {
             RuntimeException e = new RuntimeException(
                 this + " sendMessageAtTime() called with no mQueue");
             Log.w("Looper", e.getMessage(), e);
         }
         return sent;
     }

　　这个是Message入队的操作，看代码，既然说到入队，那么自然就少不了需要队列来存储这个Message，Line4，得到这个消息队列。然后准备入队；

　　Line6：这个操作很重要，为什么要交付这个Targe，因为这里在出队列的时候要用到，出队后要调用handlermessge方法，进行消息处理，如何调用handlemessge方法，在Android的世界里基本就是指对象，很显然这里targe指向了当前对象this；（不懂没关系，后边会在补充讲解）

　　Line7:进行入队操作，返回入队的最终结果，如果是true则代表成功入队，否则为失败；

 final boolean enqueueMessage(Message msg, long when) {
         if (msg.when != 0) {
             throw new AndroidRuntimeException(msg
                     + " This message is already in use.");
         }
         if (msg.target == null && !mQuitAllowed) {
             throw new RuntimeException("Main thread not allowed to quit");
         }
         final boolean needWake;
         synchronized (this) {
             if (mQuiting) {
                 RuntimeException e = new RuntimeException(
                     msg.target + " sending message to a Handler on a dead thread");
                 Log.w("MessageQueue", e.getMessage(), e);
                 return false;
             } else if (msg.target == null) {
                 mQuiting = true;
             }

             msg.when = when;
             //Log.d("MessageQueue", "Enqueing: " + msg);
             Message p = mMessages;
             if (p == null || when == 0 || when < p.when) {
                 msg.next = p;
                 mMessages = msg;
                 needWake = mBlocked; // new head, might need to wake up
             } else {
                 Message prev = null;
                 while (p != null && p.when <= when) {
                     prev = p;
                     p = p.next;
                 }
                 msg.next = prev.next;
                 prev.next = msg;
                 needWake = false; // still waiting on head, no need to wake up
             }
         }
         if (needWake) {
             nativeWake(mPtr);
         }
         return true;
     }

　　Line2 Line6很显然如果这两个对象为Null则直接就是throw exception；为什么这样那？？？？因为这handler必须的两个字段。

　　时间：标记何事处理这个Message;

　　Target：应该由谁来处理;

　　两者缺一不可，否则Handler就不是Handler了。。。。。。。

　核心代码Line20--36

 ................
          msg.when = when;
             //Log.d("MessageQueue", "Enqueing: " + msg);
             Message p = mMessages;
             if (p == null || when == 0 || when < p.when) {
                 msg.next = p;
                 mMessages = msg;
                 needWake = mBlocked; // new head, might need to wake up
             } else {
                 Message prev = null;
                 while (p != null && p.when <= when) {
                     prev = p;
                     p = p.next;
                 }
                 msg.next = prev.next;
                 prev.next = msg;
                 needWake = false; // still waiting on head, no need to wake up
             }
         ...................

　　Line5的判断是拿当前即将进行出队的Message的when做对比，如果你的时间小(也就是你应该被优先出队)，那么久交换当前的出队对象，很显然，现在Message就在事队列的最前端，等出队的时间到了就执行出队操作。

　　Line9，这是入队操作不同点就是需要执行插入的操作，为什么要插入哪？因为Message的排序是按照When来排序的谁的When小谁在前边，这样出队就不会出错，保证出队的有序性。首先声明一个temp变量prev，然后从队列的首位置开始，根据时间when的大小进行比较，如果找到合适的就交换交换类似C中的指针方式。建议大家绘制个草图，可以很明显的看出交换过程!

　　到了这里Message就完成了入队的操作，在整个入队的操作大家是否注意到一个问题，MessageQueu怎么出现的！！！！！

<:>讲述Message的初始化代码：

　　说先追根溯源，第一次使用的地方就是Handler中，很好咱们就从这里入手吧!!!

 public Handler() {
         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 = null;
     }

　　Line 16进行赋值 的操作，很显然最初的创建位置并不是这里，这里只是通过looper对象得到的改队列的引用，而并不是在这里进行了Create.

　　Line 11这里有说道搞Looper对象的获取，既然咱们是通过Looper对象获取的队列对象，那么是不是咱们可以进入这个类看下原因为几何？？？

  private Looper() {
         mQueue = new MessageQueue();
         mRun = true;
         mThread = Thread.currentThread();
     }

　　Line2说明这个问题，Looper对象创建的时候，初始化了这个MessageQueue.

<>><>到这里基本咱们说完了怎么入队，以及队列的由来，那么接下来就看怎么出队的操作！！！！

　说道出队，自然就说到咱们的《Looper，轮询器》

　既然Looper是轮询器，那么根据java面向对象的思想，这里自然就会偶轮训的方法loop；

　　<<<<<果不其然>>>>>

    /**
      *  Run the message queue in this thread. Be sure to call
      * {@link #quit()} to end the loop.
      */
     public static final void loop() {
         Looper me = myLooper();
         MessageQueue queue = me.mQueue;
         while (true) {
             Message msg = queue.next(); // might block
             //if (!me.mRun) {
             //    break;
             //}
             if (msg != null) {
                 if (msg.target == null) {
                     // No target is a magic identifier for the quit message.
                     return;
                 }
                 if (me.mLogging!= null) me.mLogging.println(
                         ">>>>> Dispatching to " + msg.target + " "
                         + msg.callback + ": " + msg.what
                         );
                 msg.target.dispatchMessage(msg);
                 if (me.mLogging!= null) me.mLogging.println(
                         "<<<<< Finished to    " + msg.target + " "
                         + msg.callback);
                 msg.recycle();
             }
         }
     }

　　代码484很少，哈哈哈哈，开森死人了、、、、、

　　直奔主题走；Line22;这个Targe大家还记得不，(忘了去前边再去复习，真都比)上边说到这个是Handler对象，那么这里调用的方法dispatchMessage进行的Message的分发操作，自然分发最后还是交给了Handler，一起看下咱们说的队不对吧，去Handler找下这个方法？？？？

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

　　机会就是给准备的人，麻痹我终于还是给我找到了。。。。

　　看方法Line13，这里干嘛了，前边的对于咱们的简单实用的时候尽管放心，没用，因为你没指定callback，所以自然就会走handleMessage方法中来，这个方法熟悉不！！！！！

　　那个谁》》》》》你说啥不熟悉，奶奶的脚丫子滚蛋，，，，初始化Handler的时候 ，大家重载的那个方法就是这个了。。。

　　

　　哟，貌似忘记了啥，哦对了，子线程new handler crash问题，，，，，走看看去，报错的位置以及log484这。。。。

　　

  mLooper = Looper.myLooper();
         if (mLooper == null) {
             throw new RuntimeException(
                 "Can't create handler inside thread that has not called Looper.prepare()");
         }

　　这里是要looper的时候，发现木有，，，，，Why，，，思考下咯，为啥没，那就看看哪里new Looper》？？？？？？？

　　查源码发现还是在Looper类中new类。。。

　　

 /** 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 final void prepare() {
         if (sThreadLocal.get() != null) {
             throw new RuntimeException("Only one Looper may be created per thread");
         }
         sThreadLocal.set(new Looper());
     }

额，这就是prepare方法了，也是就是大家禅说的子线程初始化的时候为啥调用这个方法，原因就是这了？？？？

先这样，6666666666