android那些事--- Handler和Looper的纯洁关系

       很久很久以前我们就知道，android主线程和子线程通过Handler来通讯，比如在主线程里定义Handler，实现handleMessage 接口，子线程里调用sendMessage方法发送消息，然后主线程就知道了，调用handleMessage来处理这个消息。

 

        一来一回这就完事了，看起来是很纯洁很简单的男女关系。但事实上真的这样吗？sendMessage把消息发送到哪里去了？也许你要说，每个成功的男人背后都有一个伟大的女人，一个Handler的背后一定有一个任劳任怨的循环looper！恭喜你，答对了，奖品没有。这个我们从Handler类的构造函数就能看出来，虽然有四个构造函数，但每个构造函数里面都有Looper的身影，而且后面还跟着一个mQueue！到这里我们似乎云开见日了，Handler 内部都有一个Looper一直在运转，Looper里不停的操作一个MessageQueue，Handler的sendMessage方法把消息插入到了这个mQueue，而Looper发现有了新的mQueue，就调用handleMessage接口来处理。

      说到这，我们发现了，looper才是关键，Handler只是looper的消息插入接口罢了，是浮云啊。其实，Looper是android为线程配备的一个工具，用来做线程间通讯，一个线程里只能有一个Looper。而且在activity启动时，android还为进程创建了一个MainLooper，插一句，应用程序的第一个线程，是主线程，其实就是进程，也称为根线程。

在ActivityThread.java里有个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);

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

        Looper.prepareMainLooper();//创建mainlooper
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();//创建mainhandler
        }

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

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

        Looper.loop();//开启mainlooper的循环

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

        大家一看，就真相了，android系统在启动应用时，给主线程配备了一个mainLooper，并且启动mainLooper的循环。

至于应用里面后来创建的子线程，就没这待遇了，谁让你不是爹呢？所以在主线程里面使用Handler的时候，你不需要新建Looper，而在子线程里使用Handler的时候，

你就必须构造一个Looper。

        Handler的构造函数分两种，一种是不含  Looper 参数的，一种是含有Looper参数的。不含参数的构造函数，使用Looper.myLooper()方法获取本线程的Looper。      

mainHandler = new Handler() 等价于new Handler（Looper.myLooper()）. 而Looper.getMainLooper() 用于获取主线程的Looper对象。 

        在非主线程中直接new Handler() 会报如下的错误:
E/AndroidRuntime( 6173): Uncaught handler: thread Thread-8 exiting due to uncaught exception
E/AndroidRuntime( 6173): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
        原因是非主线程被创建时，android系统不会为他创建Looper对象，所以需要手动先调用Looper.prepare()来创建一个Looper。看下这个方法，

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

sThreadLocal是线程本地存储空间的意思，每个线程有自己的独立空间。前面说了，Looper是线程唯一的，这不是瞎说吹牛逼的，貌似就是因为这里。

我们看到，prepare方法会先从线程本地存储空间里取一下，看有没有创建过Looper。然后就是创建Looper，保存在线程本地存储空间。

而myLooper方法就是取出当前线程的Looper。

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

      关于mainLooper的创建、存储和获取，Looper类单独给了一套接口：

public static void prepareMainLooper() {
        prepare();
        setMainLooper(myLooper());
        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 Looper getMainLooper() {
        return mMainLooper;
    }

       当当当当！ 好戏总是压轴的，最后上台的是Looper的核心，loop循环处理方法！

public static void loop() {
        Looper me = myLooper();//Looper到位
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        MessageQueue queue = me.mQueue;//queue到位
       
        // 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();//身份确认
       
        while (true) {
            Message msg = queue.next(); // 从队列取出一个消息，没消息的时候会阻塞
            if (msg != null) {
                if (msg.target == null) {//每个女人都有个对象，每个消息都有个target，没对象的女人要不得，没target的消息不能要
                    // No target is a magic identifier for the quit message.
                    return;
                }

                long wallStart = 0;
                long threadStart = 0;

                // 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);
                    wallStart = SystemClock.currentTimeMicro();
                    threadStart = SystemClock.currentThreadTimeMicro();
                }

                msg.target.dispatchMessage(msg);//分发消息，这个方法是目标Handler的方法，这里面调用了handleMessage！

                if (logging != null) {
                    long wallTime = SystemClock.currentTimeMicro() - wallStart;
                    long threadTime = SystemClock.currentThreadTimeMicro() - threadStart;

                    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
                    if (logging instanceof Profiler) {
                        ((Profiler) logging).profile(msg, wallStart, wallTime,
                                threadStart, threadTime);
                    }
                }

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

类Handler的dispatchMessage方法：

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