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