Looper与Handler解析

写这篇文章的目的并不仅仅是为了将Looper和Handler，一方面是为后面其他相关的介绍做铺垫，另一方面是这个东西比较重要，自己也想认真的梳理一下,也想提醒一下大家，虽然关于这个的介绍网上已经有很多。
大家通常都会使用Handler+Thread组合，在Thread里面执行耗时的操作，然后使用Handler来执行UI的更新操作，但可能根本不知道其中的缘由，或者根本就不知在Handler的背后还有Looper的存在。
Looper和Handle的完整组合是这样的:
1、创建Looper:Looper.prepare();
2、执行消息队列的循环:Looper.loop()
3、handler向Looper的消息队列中发送消息。
首先我们来看段代码：

public class MainActivity extends Activity {
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Looper.prepare();
        Looper.loop();
        mHandler.sendEmptyMessage(0);
    }
}

这段代码完全按照上面的步骤，但是运行后，程序直接崩溃报错。当然我们一般都不是这么来用的，这里为了说明一个问题。
首先来看看错误信息：java.lang.RuntimeException: Only one Looper may be created per thread
意思是说在每个线程中只能创建一个Looper,这就证明了，我们平时在UI主线程中使用Handle的时候，其实背后已经执行过了Looper.prepare()和Looper.loop()，并且创建了Looper,不用我们再来运行了。
我们通常的用法是这样的：

public class MainActivity extends Activity {
    private Handler mHandle = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            //进行界面的更新操作
            super.handleMessage(msg);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new Thread(new Runnable() {
            @Override
            public void run() {
                //执行耗时操作
                //执行完了通知UI线程进程进行界面更新
                mHandle.sendEmptyMessage(0);
            }
        }).start();

    }
}

当然上面的代码存在着内存泄漏的问题，这里我们先不做考虑，把心思放在我们今天要讲的重点上，关于为什么出现这个问题后面再做讨论。这里就直接在我们定义的线程和UI线程中使用Handle进行通信，下面我们要进行两步讲解：

1、在UI线程中，Looper.prepare()和Looper.loop()在哪里执行的？

在Activity启动过程中会执行系统源码frameworks/base/core/java/android/app/ActivityThread.java文件。
我们来看看里面的main()函数：

public static void main(String[] args) {
    ......
    Looper.prepareMainLooper();
    ......
    Looper.loop();
    ......
}

这下你应该看到了两个比较熟悉的面孔了吧！

2、怎样使用Looper和Handler实现线程间的通信？

首先让我们来看看Looper这个类主要包含哪些东西：

里面有一个ThreadLocal对象，有一个MessageQueue对象。
ThreadLocal主要用来保存数据，它是主要跟线程绑定，即存放对应线程中对应的数据,具体的原理这里就不展开了。
再来看源码，首先看Looper.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));
    }

看到if语句里面抛出的异常，是不是感觉比较熟悉，我们前面的那个异常就是这里抛出的，在prepare里面会创建一个Looper对象，把它放入ThreadLocal里面，但是在这个线程里面，Looper对象只能创建一次，所以前面会首先取出当前线程中的Looper进行判断，看是否已经创建，如果已经存在就会报错，这也是我们前面报错的原因，也就是说Looper对象只能有一份。
再看看Looper.loop()函数:

public static void loop() {
        final Looper me = myLooper();
        //从返回的异常可以看出，调用这个函数前，必须先调用Looper.prepare()函数。
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //在创建Looper对象的构造函数中，会创建消息队列，所以这里就可以直接使用
        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);
            }
            //target里面存放的是Handle对象，使用handle进行消息分发，最终就会回调handleMessage方法
            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();
        }
    }

现在我们来好好的分析一下我通常一般使用Handler的内部流程：

public class MainActivity extends Activity {
    private Handler mHandle = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            //进行界面的更细操作
            super.handleMessage(msg);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new Thread(new Runnable() {
            @Override
            public void run() {
                //执行耗时操作
                //执行完了通知UI线程进程进行界面更新
                mHandle.sendEmptyMessage(0);
            }
        }).start();

    }
}

上面已经提过，在UI线程中已经运行过了Looper.prepare()和Looper.loop()。所以在UI线程中已经有一个Looper对象，并且在Looper对象中有一个消息队列。
在我们自定义线程中来向UI线程发送消息是怎么实现的呢？我接着看Handle里面的源码，一步一步进行跟踪,我们先看Handler的构造函数，因为我们首先创建了一个Handler对象：

    public Handler() {
        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());
            }
        }
        //这里获取到UI线程中创建的那个Looper对象
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }

        //获取Looper里面的消息队列
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

接着就是发送消息的流程：

public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    }

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        //创建一个消息，把这个消息发送出去
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        //把Looper里的消息队列赋值给queue
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        //这里会把handler对象赋值给Message的taget对象，这样就可以在消息队列中回调Handle里面的handleMessage方法
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //最终往Looper那个对象的消息队列中把消息放进去
        return queue.enqueueMessage(msg, uptimeMillis);
    }

消息放进去了之后，我们再来看看上面的Looper.loop()函数，在里面有msg.target.dispatchMessage(msg)这条语句，获取到消息后，因为msg的target里面存放的是就是这个Handle对象，这样就可以得到这个Handler对象，然后利用这个Handler进行消息的分发。
我们接着跟踪源码：

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

可以看到在这里最终回调到了handleMessage这个方法。这样我们就在UI线程中通过Looper的消息队列获取到这个消息，并且回调了Handler里的handleMessage方法，就可以进行UI的更新操作。