一：android 程序和執行緒

程序是程式執行的一個例項。android通過4大主件，弱化了程序的概念，尤其是在app層面，基本不需要關係程序間的通訊等問題。

但是程式的本質沒有變，尤其是多工系統，以事件為驅動的軟體系統基本模式都是如下：

程式的入口一般是main：

1.初始化：

比如建立視窗，申請資源等。

2.進入while（true）

在迴圈中處理各種事件，直到程序退出。

四大元件是程序的部分載體，配置程序在androidmanifest.xml裡面，android:process 屬性。

當然預設所有的都在同一個程序裡面，由application裡面配置，預設程序為apk的包名。

執行緒是程序的有機組成部分，是CPU排程的基礎。

一般情況下，都有主執行緒和其他執行緒之分，只有主執行緒才可以重新整理UI。

應用程式啟動後，將建立ActivityThread 主執行緒。

不同包名的元件可以一定的方式執行在同一個程序中。

一個Activity啟動後，至少會有3個執行緒。一個主執行緒和2個binder執行緒。

二：android 程序內的訊息驅動機制---Handler,MessageQueue,Runnable,Looper

1.Runnable & MessageQueue:

Runnable 和Message 是訊息的2種載體。

訊息的行為本質上就是 一段操作Runnable，或者是一段資料Message，包含這操作內容，由handlemessage來判斷處理。

他們的操作方式就是：

public final boolean post(Runnable r)
{
　　return sendMessageDelayed(getPostMessage(r), 0);
}

public final boolean postAtTime(Runnable r, long uptimeMillis)

public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)

上面就是Runnable的方法，可以看到Runnable會被分裝成Message的形式傳送。

    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

所以本質上，都是以Message的封裝方式處理。

最終所有的訊息都會放入MessageQueue裡面。

MessageQueue並不是一個真正的佇列，而是連結串列。

Looper就是迴圈在某件事情，類似於while（true）乾的事情。

Handler就是真正做事情的。

Looper不斷的從MessageQueue從取出資料，然後交給handler來處理。

2.Handler:

framework/base/core/android/os/Handler.java

其實handler的作用，它的註釋已經解釋的非常清楚。

/**
 * A Handler allows you to send and process {@link Message} and Runnable
 * objects associated with a thread's {@link MessageQueue}.  Each Handler
 * instance is associated with a single thread and that thread's message
 * queue.  When you create a new Handler, it is bound to the thread /
 * message queue of the thread that is creating it -- from that point on,
 * it will deliver messages and runnables to that message queue and execute
 * them as they come out of the message queue.
*
 * <p>There are two main uses for a Handler: (1) to schedule messages and
 * runnables to be executed as some point in the future; and (2) to enqueue
 * an action to be performed on a different thread than your own.
*
 * <p>When posting or sending to a Handler, you can either
 * allow the item to be processed as soon as the message queue is ready
 * to do so, or specify a delay before it gets processed or absolute time for
 * it to be processed.  The latter two allow you to implement timeouts,
 * ticks, and other timing-based behavior.
*/

這個一共三段內容，大意是：

1）handler使用runnable或者message的方式傳遞，儲存在一個thread的messagequeue裡面。

當你建立一個新的handler的時候，他會與這個建立它的執行緒繫結。

對於一個Thread 來說MessageQueue,和Looper只有一個。

2）使用handler一般有2種場景。

希望do runnable或者某種Message 在in the future.

或者把一個action（Runnable or Message）傳遞到其他執行緒進行操作。

常見的操作就是在工作執行緒中使用主執行緒handler來操作UI。

3）你可以讓handler直接操作message內容，或者等待一段時間，這個時間是可以配置的。

handle的2大功能

處理message：

public void dispatchMessage(Message msg) 分發訊息
public void handleMessage(Message msg)   處理訊息，該方法通常情況下，須由子類繼承。

Looper.loop()方法會呼叫dispatchMessage來處理訊息。

    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

handler的子類通過過載該方法，可以修改handler的訊息派發方式。

handler的第二個作用是把message & Runnable分裝到MessageQueue裡面。

handler，messagequeue，looper目的是什麼，目的就是啟動訊息機制。

MessageQueue:

MessageQueue從哪裡得到，從Handler原始碼看到，是從Looper裡面來的。

    public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

Looper：

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

Looper 建構函式就幹了2件事。

建立Messagequeue，所以 每個Looper都有唯一的一個MessageQueue與之對應。

得到執行thread。

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

Looper有個特殊的變數，ThreadLocal， 這個物件只對自己所在的執行緒全域性，其他的執行緒無法看到它。

Looper提供了很多static的方法，所以肯定還有一些能都識別“身份“的方法。

這些方法在我們使用looper 的時候，最重要的是如下2個：

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycle();
        }
    }

prepare才是looper建立以及和thread繫結的地方。

looper.loop()方法是整個looper機制啟動的地方。

從此thread就會接受訊息和處理訊息了。

這裡有個小問題：

            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

一開始的時候，MessageQueue handler沒有傳遞訊息進佇列，按理說取到的訊息是null，這樣looper就直接退出了。

這個問題等到分析原始碼的時候，在解決。

這樣handler，messaqequeue,looper, 和thread都關聯起來了。

下面還有一個mainlooper的問題。

public static void main(String[] args) {
    ...

    Looper.prepareMainLooper();

    if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

    Looper.loop();
}

以上是ActivityThread的部分入口函式main的原始碼：

可見prepareMainLooper()的方法，是給主執行緒使用的。

而looper那邊的

private static Looper sMainLooper;  // guarded by Looper.class

是為了給其他執行緒應用使用。

這樣其他執行緒可以給主執行緒發訊息。

如圖所示：主執行緒的looper將由sMainLooper作為應用，儲存在static空間中，其他工作執行緒可以訪問它

 至此，整個訊息機制的框架已經驅動起來。

本文參考：

1.《深入理解android核心設計思想》林學森

2.《Android核心剖析》

相關文章：