Handler,Thread,Looper,MessageQue

Android 是由事件驱动的，在Android中，主线程（也就是UI线程）是不安全的，当在主线程处理消息过长时，非常容易发生ANR（Application Not Responding）问题；其次，如果我们在子线程中尝试进行UI的操作，程序就可能还会直接崩溃，这就是UI线程被阻塞导致的，归根结底其实是Looper被当前事件（也就是当前正在处理的消息）阻塞住导致的。在android系统中Looper通过Looper.loop() 不断地接收事件、处理事件，每一个点击，触摸包括Activity的生命周期都是运行在 Looper.loop() 的控制之下，如果它停止了，应用也就停止了，所有Looper的生命周期是伴随整个应用的。

我们先来分析一下Handler

要创建一个Handler对象非常的简单明了，直接进行new一个对象即可mHandler0 = new Handler()，但这里其实还隐藏着一个信息，那就是这个mHadler也就是在此刻和当前线程中的Looper进行了隐匿绑定，看下面代码
<pre><code>
public class MainActivity extends ActionBarActivity {

private Handler mHandler0;

private Handler mHandler1;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mHandler0 = new Handler();
    new Thread(new Runnable() {
        @Override
        public void run() {
            mHandler1 = new Handler();
        }
    }).start();
}

</code></pre>
这一小段程序代码主要创建了两个Handler对象，其中，一个在主线程中创建，而另外一个则在子线程中创建，现在运行一下程序，则你会发现，在子线程创建的Handler对象竟然会导致程序直接崩溃，提示的错误竟然是Can't create handler inside thread that has not called Looper.prepare()

于是我们按照logcat中所说，在子线程中加入Looper.prepare(),即代码如下：

new Thread(new Runnable(){

    @override
    public void run(){
        Looper.prepare();
        mHandler1 = new Handler()
    }
}).start();

再次运行一下程序，发现程序不会再崩溃了，可是，单单只加这句Looper.prepare()是否就能解决问题了。我们探讨问题，就要知其然，才能了解得更多。我们还是先分析一下源码吧，看看为什么在子线程中没有加Looper.prepare()就会出现崩溃，而主线程中为什么不用加这句代码？我们看下Handler()构造函数：

public Handler() {
    this(null, false);
}

构造函数直接调用this(null, false)，于是接着看其调用的函数，

 public Handler(Callback callback, boolean async) {
        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 = callback;
        mAsynchronous = async;
    }

不难看出，源码中调用了mLooper = Looper.myLooper()方法获取一个Looper对象，若此时Looper对象为null，则会直接抛出一个“Can't create handler inside thread that has not called Looper.prepare()”异常，那什么时候造成mLooper是为空呢？那就接着分析Looper.myLooper()，

   public static Looper myLooper() {
        return sThreadLocal.get();
   }

这个方法在sThreadLocal变量中直接取出Looper对象，若sThreadLocal变量中存在Looper对象，则直接返回，若不存在，则直接返回null，而sThreadLocal变量是什么呢？

static final ThreadLocat<Looper> sThreadLocal = new ThreadLocal<Looper>();

它是本地线程变量，由此看到，我们的判断是正确的，在Looper.prepare()方法中给sThreadLocal变量设置Looper对象，看看源码

public static void prepare() {
      prepare(true);
  }

直接调用了带个boolean参数的prepare函数

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

这样也就理解了为什么要先调用Looper.prepare()方法，才能创建Handler对象，才不会导致崩溃。所以我们可以看到，一个线程在调用Looper的静态方法prepare()时，这个线程会新建一个Looper对象，并放入到线程的局部变量中，而这个变量是不和其他线程共享的，但是，仔细想想，为什么主线程就不用调用呢？不要急，我们接着分析一下主线程，我们查看一下ActivityThread中的main()方法，代码如下：

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

    // CloseGuard defaults to true and can be quite spammy.  We
    // disable it here, but selectively enable it later (via
    // StrictMode) on debug builds, but using DropBox, not logs.
    CloseGuard.setEnabled(false);

    Environment.initForCurrentUser();

    // Set the reporter for event logging in libcore
    EventLogger.setReporter(new EventLoggingReporter());

    Security.addProvider(new AndroidKeyStoreProvider());

    // Make sure TrustedCertificateStore looks in the right place for CA certificates
    final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
    TrustedCertificateStore.setDefaultUserDirectory(configDir);

    Process.setArgV0("<pre-initialized>");

    Looper.prepareMainLooper();

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

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

    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }

    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

代码中调用了Looper.prepareMainLooper()方法，而这个方法又会继续调用了Looper.prepare()方法。

分析到这里已经真相大白，主线程中google工程师已经自动帮我们创建了一个Looper对象了，因此我们不再需要手动再调用Looper.prepare()再创建，而子线程中，因为没有自动帮我们创建Looper对象，因此需要我们手动添加，调用方法是Looper.prepare()，这样，我们才能在子线程中正确地创建Handler对象。

再来分析Looper

在上面的过程中，我们对Looper也了解了不少，一个线程仅有一个Looper对象，主线程中的Looper对象是由系统为我们自动创建的，并通过Looper.loop()方法开启消息循环，不停的从MessageQueue中取出msg，然后通过msg.target.dispatchMessage(msg)方法交给对应的Handler的handleMessage()方法进行处理，而不难看出，此时msg.target就是Handler对象。概括性来说，Looper负责的是创建一个MessageQueue对象，然后进入到一个无限循环体中不断取出消息，而这些消息都是由一个或者多个Handler进行创建处理。

关于MessageQueue

消息池，负责管理消息队列，实际上Message类有一个next字段，会将Message对象串在一起成为一个消息队列。MessageQueue是在Looper被创建的时候被同时创建的，从下面Looper的构造方法可以看出

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

仔细想一下上面的Handler的构造方法，其中有这么一行mQueue = mLooper.mQueue; 明白了吧，Looper和Handler拥有的是同一个MessageQueue，也就是说这个queue是由它们两个共同来维护的，其实这也是必须的，Handler通过sendMessage（Message msg）等方法发送消息，然后再通过enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法进行消息入队列操作，而Looper.loop()不停的在从该消息队列中取出消息，然后调用msg.target.dispatchMessage(msg)去处理该消息。

最后，是否清楚这个几者之间的对应关系呢，分析一下：

线程和handler是一对多关系，一个线程里可以有一个或者多个Handler；而线程和Looper则是一对一的关系，一个线程里只会存在一个Looper；
那么，从以上两个对应关系，可知，一个线程中的Handler和Looper是多对一的关系，由于一个Looper中有就一个mQueue,那么Handler和MessageQueue的关系也是多对一了,因为handler里的mQueue都是从Looper中拿到的；

那么，消息发送机制就是这样的：

一个线程里的一个或多个handler向mQueue发送消息，线程里的Looper通过Looper.loop()不停的在从该消息队列中取出消息，然后通过该消息的msg.target去获知发送这个消息的handler是谁，之后调用msg.target.dispatchMessage(msg)去处理该消息。