android Looper HandlerThread MessageQueue Handler Message（完善中......）

ActivityThread.java 的 main主函数启动入口

 public static final void main(String[] args) {
 Process.setArgV0("<pre-initialized>");

 Looper.prepareMainLooper();

 ActivityThread thread = new ActivityThread();
 thread.attach(false);

 Looper.loop();

 if (Process.supportsProcesses()) {
 throw new RuntimeException("Main thread loop unexpectedly exited");
 }

 thread.detach();
 String name;
 if (thread.mInitialApplication != null) name = thread.mInitialApplication.getPackageName();
 else name = "<unknown>";
 Log.i(TAG, "Main thread of " + name + " is now exiting");
 }

Looper.java

从prepareMainLooper方法的注释可以理解，初始化当期线程，而looper和一个线程关联，并且提供了主线程looper对象的对外接口

    /** Initialize the current thread as a looper, marking it as an application's main
     *  looper. The main looper for your application is created by the Android environment,
     *  so you should never need to call this function yourself.
     * {@link #prepare()}
     */
     
    public static final void prepareMainLooper() {
        prepare();
        setMainLooper(myLooper());
        if (Process.supportsProcesses()) {
            myLooper().mQueue.mQuitAllowed = false;
        }
    }


    private synchronized static void setMainLooper(Looper looper) {
        mMainLooper = looper;
    }
    
    /** Returns the application's main looper, which lives in the main thread of the application.
     */
    public synchronized static final Looper getMainLooper() {
        return mMainLooper;
    }

初始化当前线程，之后把一个初始化的Looper关联线程，在Looper初始化的时候做了一些操作就是初始化了一个消息队列MessageQueue即通过Looper来管理MessageQueue，通过调用Looper.myLooper()可以获得当前线程的Looper对象，但是Looper的构造函数是私有的，外界无法直接实例化之；要实例化，只有通过Looper::prepare()

    // sThreadLocal.get() will return null unless you've called prepare().
    private static final ThreadLocal sThreadLocal = new ThreadLocal();

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

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

    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static final Looper myLooper() {
        return (Looper)sThreadLocal.get();
    }

looper里面的消息队列进行循环机制，执行消息队列里面的一个个消息，注意msg.target是个Handler对象

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

轮循中开始处理系统的一个个消息，两种情况一种正常消息处理，一种回掉处理；其中

handleMessage(msg)为需要用户自己继承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);
        }
    }

    /**
     * Subclasses must implement this to receive messages.
     */
    public void handleMessage(Message msg) {
    }

理解下HandlerThread，你会发现HandlerThread继承Thread，HandlerThread::run()里面调用了Looper的初始化prepare();和looper()。

    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            Process.setThreadPriority(mPriority);
            notifyAll();
        }
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

理解Handler，从下面的Handler构造函数可以了解Handler的构造是需要Looper对象的，没有参数Looper的构造函数是用当前线程的looper对象；而当然你也可以通过HandlerThread施行run后就有了looper对象，通过对外的接口getLooper（）可以获取此Looper对象，MessageQueue在looper中是一个属性，所以你需要记忆这个。

    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;
    }


    /**
     * Use the provided queue instead of the default one.
     */
    public Handler(Looper looper) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = null;
    }

说明：对于以上的理解我在最后会有实例来验证说明，到这里我们的疑问是现在我们想知道 消息是怎么封装的，消息是怎么放入消息队列的？

消息的入消息队列

    /**
     * Pushes a message onto the end of the message queue after all pending messages
     * before the current time. It will be received in {@link #handleMessage},
     * in the thread attached to this handler.
     *  
     * @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 sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }


  /**
     * Enqueue a message into the message queue after all pending messages
     * before (current time + delayMillis). You will receive it in
     * {@link #handleMessage}, in the thread attached to this handler.
     *  /
    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }


    /**
     * Enqueue a message into the message queue after all pending messages
     * before the absolute time (in milliseconds) <var>uptimeMillis</var>.
     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
     * You will receive it in {@link #handleMessage}, in the thread attached
     * to this handler.
     * /
    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;
    }


    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");
        }
        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;
                this.notify();
            } else {
                Message prev = null;
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
                msg.next = prev.next;
                prev.next = msg;
                this.notify();
            }
        }
        return true;
    }

通过上面的理解，用实例来验证上面的理解，下面是我以前项目中写的代码。

实例一：在一个activity耗时的操作方法中自己起了一个线程

Thread th = new Thread() {

	public void run() {
Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
								public void run() {
									Toast.makeText(MailView.this, "�ʼ����ͳɹ�",
											Toast.LENGTH_LONG).show();
								}
							}
)
      }
}
th.start();

实例二：Service中,这里注意下，Message的对象创建Message::obtain()，这个对象也可以是Handler的obtainMessage()来创建。

	private final Handler handler = new Handler() {
		public void handleMessage(Message msg) {
			super.handleMessage(msg);
			switch (msg.what) {
			case MSG_TIMER:
				mWorker = new HandlerThread("MyWorker");
				mWorker.start();
				mWorkerHandler = new Handler(mWorker.getLooper());
				mWorkerHandler.postDelayed(new MessageReceiveTask(),
						SECONDRESOLVERMESSAGE);
				break;
			}
		}
	};


	public void onCreate() {
		super.onCreate();
		Log.i(Constant.TAG_INFO,
				"StartService*****************************************");
		Message msgget = Message.obtain();
		msgget.what = MSG_TIMER;
		handler.sendMessageDelayed(msgget, SECONDRESOLVERMESSAGELONG);
	}

<pre name="code" class="java"> class MessageReceiveTask implements Runnable {
		public void run() {
			try {
				loadInitInboxData();
			} catch (Exception e) {
				Log.i(Constant.TAG_EXCEPTION, "MessageReceiveTask  :  " + e);
			}
			mWorkerHandler.postDelayed(this, SECONDRESOLVERMESSAGE);
		}
	}</pre>

从上面我写的代码可以看到发送有两种方式，sendMessage(m)和postDelayed(r)两种，我列出源码

    /**
     * Causes the Runnable r to be added to the message queue.
     * The runnable will be run on the thread to which this handler is 
     * attached. 
     */
    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }


   /**
     * Causes the Runnable r to be added to the message queue, to be run
     * after the specified amount of time elapses.
     * The runnable will be run on the thread to which this handler
     * is attached.
     *  
     */
    public final boolean postDelayed(Runnable r, long delayMillis)
    {
        return sendMessageDelayed(getPostMessage(r), delayMillis);
    }


   /**
     * Causes the Runnable r to be added to the message queue, to be run
     * at a specific time given by <var>uptimeMillis</var>.
     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
     * The runnable will be run on the thread to which this handler is attached.        
     * @see android.os.SystemClock#uptimeMillis
     */
    public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    } 

 /**
 * Pushes a message onto the end of the message queue after all pending messages
 * before the current time. It will be received in {@link #handleMessage},
 * in the thread attached to this handler.
 */
 public final boolean sendMessage(Message msg)
 {
 return sendMessageDelayed(msg, 0);
 }


 /**
 * Enqueue a message into the message queue after all pending messages
 * before (current time + delayMillis). You will receive it in
 * {@link #handleMessage}, in the thread attached to this handler.
 */
 public final boolean sendMessageDelayed(Message msg, long delayMillis)
 {
 if (delayMillis < 0) {
 delayMillis = 0;
 }
 return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
 }

 /**
 * Enqueue a message into the message queue after all pending messages
 * before the absolute time (in milliseconds) <var>uptimeMillis</var>.
 * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
 * You will receive it in {@link #handleMessage}, in the thread attached
 * to this handler.
 */
 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的创建，请注意这里，先从池中取出，需要明白下面是个单向链表的形式，从注释中可以了解到：// sometimes we store linked lists of these things
Message next;如果在池中没有就从新new一个对象。

    /**
     * Return a new Message instance from the global pool. Allows us to
     * avoid allocating new objects in many cases.
     */
    public static Message obtain() {
        synchronized (mPoolSync) {
            if (mPool != null) {
                Message m = mPool;
                mPool = m.next;
                m.next = null;
                return m;
            }
        }
        return new Message();
    }

注意message要是用完后，需要回收放入池中

    /**
     * Return a Message instance to the global pool.  You MUST NOT touch
     * the Message after calling this function -- it has effectively been
     * freed.
     */
    public void recycle() {
        synchronized (mPoolSync) {
            if (mPoolSize < MAX_POOL_SIZE) {
                clearForRecycle();
                
                next = mPool;
                mPool = this;
            }
        }
    }

从// might block这个注释说开来，

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

继续说明消息是怎么取的

    final Message next() {
        boolean tryIdle = true;

        while (true) {
            long now;
            Object[] idlers = null;
    
            // Try to retrieve the next message, returning if found.
            synchronized (this) {
                now = SystemClock.uptimeMillis();
                Message msg = pullNextLocked(now); 具体的通过单向链表方式来操作的，看这个方法的具体内容就明白了。
                if (msg != null) return msg;
                if (tryIdle && mIdleHandlers.size() > 0) {
                    idlers = mIdleHandlers.toArray();
                }
            }
    
            // There was no message so we are going to wait...  but first,
            // if there are any idle handlers let them know.
            boolean didIdle = false;//no idle
            if (idlers != null) {
                for (Object idler : idlers) {
                    boolean keep = false;
                    try {
                        didIdle = true;
                        keep = ((IdleHandler)idler).queueIdle();
                    } catch (Throwable t) {
                        Log.e("MessageQueue",
                              "IdleHandler threw exception", t);
                        RuntimeInit.crash("MessageQueue", t);
                    }

                    if (!keep) {
                        synchronized (this) {
                            mIdleHandlers.remove(idler);
                        }
                    }
                }
            }
            
            // While calling an idle handler, a new message could have been
            // delivered...  so go back and look again for a pending message.
            if (didIdle) {
                tryIdle = false;
                continue;
            }

            synchronized (this) {
                // No messages, nobody to tell about it...  time to wait!
                try {
                    if (mMessages != null) {
                        if (mMessages.when-now > 0) {
                            Binder.flushPendingCommands(); 
                            this.wait(mMessages.when-now); 这里需要说明的是堵塞等待一个特定的时间
              }
                    } else {
                        Binder.flushPendingCommands();
                        this.wait(); 堵塞 ，期待唤醒
                   }
                }
                catch (InterruptedException e) {
                }
            }
        }
    }


 下面是通过比较当前系统的真实时间long来和消息的message的when时间值来比较，如果当前时间大于或等于消息时间，就把当前节点取出来，把下一个赋值给当前节点。


<pre name="code" class="java">    final Message pullNextLocked(long now) {
        Message msg = mMessages;
        if (msg != null) {
            if (now >= msg.when) {
                mMessages = msg.next;
                if (Config.LOGV) Log.v(
                    "MessageQueue", "Returning message: " + msg);
                return msg;
            }
        }

        return null;
    }
</pre>

消息的入对列也是单向列表式的操作

    final boolean enqueueMessage(Message msg, long when) {
        if (msg.when != 0) {
            throw new AndroidRuntimeException(msg
                    + " This message is already in use.");
        }
上面的msg.when！=0是因为之前这个方法被调用前没有被赋值过，如果被赋值过，则说明已经被使用中了。
        if (msg.target == null && !mQuitAllowed) {
            throw new RuntimeException("Main thread not allowed to quit");
        }
        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; 把当前的节点赋值给传进来的message的下一个，而下面一句则是把传进来的message作为最新的当前节点。 
        mMessages = msg;
 下面一句是唤醒，通过上面的判断有消息入队，则进行唤醒来进行处理。
                this.notify(); 
      } else {
                Message prev = null;
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
                msg.next = prev.next;
                prev.next = msg;
                this.notify();
            }
        }
        return true;
    }

现在你开朗了吗？。。。。。。