Android多线程基础之从Looper源码深度分析

谈到Android的多线程，绕不开Looper，首先我们看看一般来说是Android是如何进行线程间通信的：

 * <pre>  *  class LooperThread extends Thread {  *      public Handler mHandler;  *  *      public void run() {  *          Looper.prepare();  *  *          mHandler = new Handler() {  *              public void handleMessage(Message msg) {  *                  // process incoming messages here  *              }  *          };  *  *          Looper.loop();  *      }  *  }</pre>

首先要有Looper.prepare();
然后new一个Handler
最后Looper.loop();
我们今天就从源码层面深度分析实现原理：
首先看Looper中定义的变量：

 private static final String TAG = "Looper"; //利用虚拟机来进行单例的实现，sThreadLocal 应该是存储Looper对象的一个集合 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); //主线程的Looper对象 private static Looper sMainLooper;   //存储线程发来的Message对象 final MessageQueue mQueue; //当前线程 final Thread mThread;//打印日志有关 private Printer mLogging;

现在我们看Looper.prepare();中做了什么：

 public static void prepare() {        prepare(true);    } private static void prepare(boolean quitAllowed) {        //保证一个线程中只有一个Looper对象        //一个线程对应一个Looper        if (sThreadLocal.get() != null) {            throw new RuntimeException("Only one Looper may be created per thread");        }        //给sThreadLocal中添加一个Looper对象        sThreadLocal.set(new Looper(quitAllowed));    }

然后我们看看mHandler = new Handler()是怎样和Looper关联的：

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());            }        }        //通过Looper.myLooper()得到当前线程的Looper对象        mLooper = Looper.myLooper();        if (mLooper == null) {            throw new RuntimeException(                "Can't create handler inside thread that has not called Looper.prepare()");        }        //得到当前线程Looper里面的MessageQueue对象        mQueue = mLooper.mQueue;        mCallback = callback;        mAsynchronous = async;    }

我们再看看Looper.loop();做了什么：

public static void loop() {        //得到当前线程的Looper对象        final Looper me = myLooper();        if (me == null) {            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");        }        //得到MessageQueue集合        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 (;;) {            //读取MessageQueue集合中的Message            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);            }            //处理Message            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);            }            //回收Message            msg.recycle();        }    }

以上就是整个Thread和Looper的关系；但是里面有几个重要的方法：
mLooper = Looper.myLooper();
这个方法是得到当前线程中的Looper对象：
我们看看源码：

 public static Looper myLooper() {        //从sThreadLocal中获取        return sThreadLocal.get();    }

结合Looper.prepare中的sThreadLocal.set(new Looper(quitAllowed));

可以看出，不管是获取还是设置Looper对象，都是在sThreadLocal中；
下面重点分析sThreadLocal的实现：

public class ThreadLocal<T> {       public ThreadLocal() {}

从定义可以看出，里面有泛型实现的元素我；们先看看set：

 public void set(T value) {        //和当前线程建立联系        Thread currentThread = Thread.currentThread();        //后面看        Values values = values(currentThread);        if (values == null) {            values = initializeValues(currentThread);        }        //将value添加到values        values.put(this, value);    }

也就是说，将Looper对象和线程关联以后，存入到Values这个对象中：后面我接着看Values：
先看看定义和变量：

 static class Values {        private static final int INITIAL_SIZE = 16;        private static final Object TOMBSTONE = new Object();        //table是一个Object数组        private Object[] table;        private int mask;        private int size;        private int tombstones;        private int maximumLoad;        private int clean;

我们在看看：values.put(this, value);

 void put(ThreadLocal<?> key, Object value) {            cleanUp();            // Keep track of first tombstone. That's where we want to go back            // and add an entry if necessary.            int firstTombstone = -1;            //进入到一个循环中            for (int index = key.hash & mask;; index = next(index)) {                Object k = table[index];                //如果之前存在，那么替换                if (k == key.reference) {                    // Replace existing entry.                    table[index + 1] = value;                    return;                }                //否则，新建一个，然后将value存入到ThreadLocal中                //在Looper中，value其实就是Looper                if (k == null) {                    if (firstTombstone == -1) {                        // Fill in null slot.                        table[index] = key.reference;                        table[index + 1] = value;                        size++;                        return;                    }                    // Go back and replace first tombstone.                    table[firstTombstone] = key.reference;                    table[firstTombstone + 1] = value;                    tombstones--;                    size++;                    return;                }                // Remember first tombstone.                if (firstTombstone == -1 && k == TOMBSTONE) {                    firstTombstone = index;                }            }        }

其实put就是将Looper对象存储到ThreadLocal对象中的一个Object数组中；加上相应的标记；
我们再看看get

 @SuppressWarnings("unchecked")    public T get() {        // Optimized for the fast path.        Thread currentThread = Thread.currentThread();        Values values = values(currentThread);        if (values != null) {            //从Values 中的Object数组中根据标记获取对象            Object[] table = values.table;            int index = hash & values.mask;            if (this.reference == table[index]) {                return (T) table[index + 1];            }        } else {            values = initializeValues(currentThread);        }        //强转        return (T) values.getAfterMiss(this);    }

这下清楚了吧；Looper最后的归宿是在Values中的一个名字叫做table的Object数组中存储；存储的时候添加相关的标记；取的时候根据标记来取；一个Thread中只有一个Looper，一个Looper中有一个MessageQueue，一个MessageQueue中有多个Message；Handler根据Looper来构造，因此一个Thread可以对应多个Handler；以上就是Thread，Looper，MeaageQueue，Handler的关系和之间是如何建立起联系的。