Android系统源码阅读（16）：Android 应用线程的消息循环模型

本文链接：https://blog.csdn.net/tianchi92/article/details/53452917

Android系统源码阅读（16）：Android 应用线程的消息循环模型

读书不宜拖沓

0. 背景

Android应用的主线程为ActivityThread，在第（10）章已经讲过，它主要负责处理界面事件，所以开发者应该避免在主线程中处理耗时的任务。为了减轻主线程的负担，开发者应该启用多线程来处理耗时的任务。在Android中可以创建多种线程，有的线程可以有自己的消息循环，有的线程则可以向主线程发送消息来使得界面发生改变。

1. 主线程的消息循环

应用程序的主线程创建过程如下：ActivityManagerService线程请求Zygote进程创建应用进程；Zygote通过fork来创建一个新进程，新进程将ActivityThread的main作为入口进入Looper循环；Looper会调用静态成员函数prepareMainLooper创建一个Looper对象，并且在该应用进程中，该方法只会调用一次，因为只有一个主线程。

2. 子线程HandlerThread

Android应用中，创建子线程可以和java桌面应用一样，创建一个Thread子类，实现run函数，然后start即可。但是这种方式是没有消息循环的，是一种比较简单的方法。

另一种则是使用Android定制版的Thread–HandlerThread。HanlderThre ad的实现也很简单，完全可以模仿它实现一个自己的带有消息循环的Thread，或者实现一个集成HandlerThread的子类。

frameworks/base/core/java/android/os/HandlerThread.java :

/**
 * Handy class for starting a new thread that has a looper. The looper can then be
 * used to create handler classes. Note that start() must still be called.
 */
public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }

    /**
     * Constructs a HandlerThread.
     * @param name
     * @param priority The priority to run the thread at. The value supplied must be from
     * {@link android.os.Process} and not from java.lang.Thread.
     */
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }

    /**
     * Call back method that can be explicitly overridden if needed to execute some
     * setup before Looper loops.
     */
    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        //准备了looper
        Looper.prepare();
        synchronized (this) {
            //获得自己的looper
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        //进入消息循环
        Looper.loop();
        mTid = -1;
    }

    /**
     * This method returns the Looper associated with this thread. If this thread not been started
     * or for any reason is isAlive() returns false, this method will return null. If this thread
     * has been started, this method will block until the looper has been initialized.
     * @return The looper.
     */
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

    /**
     * Quits the handler thread's looper.
     * <p>
     * Causes the handler thread's looper to terminate without processing any
     * more messages in the message queue.
     * </p><p>
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
     * For example, the {@link Handler#sendMessage(Message)} method will return false.
     * </p><p class="note">
     * Using this method may be unsafe because some messages may not be delivered
     * before the looper terminates.  Consider using {@link #quitSafely} instead to ensure
     * that all pending work is completed in an orderly manner.
     * </p>
     *
     * @return True if the looper looper has been asked to quit or false if the
     * thread had not yet started running.
     *
     * @see #quitSafely
     */
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

    /**
     * Quits the handler thread's looper safely.
     * <p>
     * Causes the handler thread's looper to terminate as soon as all remaining messages
     * in the message queue that are already due to be delivered have been handled.
     * Pending delayed messages with due times in the future will not be delivered.
     * </p><p>
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.
     * For example, the {@link Handler#sendMessage(Message)} method will return false.
     * </p><p>
     * If the thread has not been started or has finished (that is if
     * {@link #getLooper} returns null), then false is returned.
     * Otherwise the looper is asked to quit and true is returned.
     * </p>
     *
     * @return True if the looper looper has been asked to quit or false if the
     * thread had not yet started running.
     */
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

    /**
     * Returns the identifier of this thread. See Process.myTid().
     */
    public int getThreadId() {
        return mTid;
    }
}

从HandlerThread的源码可以看出它提供了基本的开关功能，使用起来也很简单方便。具体如何使用如下：

首先实例化一个HandlerThread对象，然后启动这个thread。

HandlerThread handleThread = new HandlerThread("Handler Thread");
//然后启动它，因为HandlerThread是Thread的子类，所以启动方法并无差异
handleThread.start();

然后创建一个实现了Runnable接口的类。

public class ThreadTask implements Runnable{
    public ThreadTask(){
    }
    //重写该方法
    public void run(){
       //你的任务
    }
}

创建一个Runnable的实例对象，然后丢给HandleThread来处理。

ThreadTask threadTask = new ThreadTask();
//为HandlerThread的Looper创建一个Handler
Handler handler = new Handler(handlerThread.getLooper);
//通过Handler将任务给HandlerThread来执行
handler.post(threadTask);

在消息队列处理到该任务时，threadTask的run函数就会被调用执行。