Android源码之Handler(一)

在Android系统中,Handler是一个很重要的概念.可以说，在Android系统中，Handler的身影无处不在。
Handler提供了若干个构造函数，我们就从Handler的构造函数来开始分析Handler系统的实现. Handler的构造函数的实现如下：
[// Handler的构造函数
public Handler() {
        this(null, false);
    }
public Handler(Callback callback) {
        this(callback, false);
    }
public Handler(Looper looper) {
        this(looper, null, false);
    }
public Handler(Looper looper, Callback callback) {
        this(looper, callback, false);
    }
public Handler(boolean async) {
        this(null, async);
    }

public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
[// FIND_POTENTIAL_LEAKS
private static final boolean FIND_POTENTIAL_LEAKS = false;
FIND_POTENTIAL_LEAKS设置为true的时候, 会检测内存泄漏可能性.
]// 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());
    }
    [// if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && (klass.getModifiers() & Modifier.STATIC) == 0)
    检测内存泄漏是通过Java的反射机制来实现的.
    ]// if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && (klass.getModifiers() & Modifier.STATIC) == 0)
}
[// if (FIND_POTENTIAL_LEAKS)
这段代码是为了检测Handler可能的内存泄漏.当Handler被继承定义成匿名函数或者是某一类的内部类的时候,如果不把该Handler定义成static,则可能发生内存泄漏. 为什么呢?
因为不是static的内部类会默认持有一个指向父类的指针, 而发给这个Handler的Message又会持有这个Handler的指针. 这样如果这个Message不销毁的话,则这个Handler是不会被垃圾回收的.
]// if (FIND_POTENTIAL_LEAKS)

mLooper = Looper.myLooper();
[// mLooper = Looper.myLooper()
得到的是当前线程的Looper. 那么这个Looper是个什么呢?在这里我们先来看一下Looper的实现。
在Android系统中, Looper是按照如下方式使用的:
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();
                  *      }
                  *  }
            由上面的代码可以看出, 使用Looper要先调用Looper.prepare函数, 然后构造一个Handler对象，最后调用Looper.loop函数。经过上面的过程之后，就可以利用Handler机制来发送和处理消息了。
我们先来看一下prepare的实现：
public static void prepare() {
                        prepare(true);
                    }

               private static void prepare(boolean quitAllowed) {
                if (sThreadLocal.get() != null) {
                [// if (sThreadLocal.get() != null)
                   这里首先会先判断之前是否已经为线程设置过Looper
                    sThreadLocal是Looper内部定义的一个static成员变量，定义如下:
                    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
                    ThreadLocal的构造函数定义如下：
                    [// ThreadLocal的构造函数
                    public ThreadLocal() {}
                    由此可见,ThreadLocal的构造函数是个空函数,什么也不做。
                    ]// ThreadLocal的构造函数
注意，这里的成员变量sThreadLocal是static的。
我们接下来看一下ThreadLocal的get函数的实现:
public T get() {
                        // Optimized for the fast path.
                       Thread currentThread = Thread.currentThread();
                       [// Thread currentThread = Thread.currentThread()
                       这里调用Thread的currentThread函数当得到当前线程。
                       ]// Thread currentThread = Thread.currentThread()
                         Values values = values(currentThread);
                         [// Values values = values(currentThread)
                         当得到了当前线程的Thread变量之后, 会调用values函数。values函数的定义如下:
                         Values values(Thread current) {
                                return current.localValues;
                              }
                              values函数会直接返回Thread变量的localValues变量，由此可知，其实TheadLocal机制其实是将值保存到每一个Thread变量中去的.
                         ]// Values values = values(currentThread)
                           if (values != null) {
                           [// if (values != null)
                             下面这段代码是在当前线程的localValues成员变量中取ThreadLocal保存的值。
                            ]// if (values != null)
                            Object[] table = values.table;
                               int index = hash & values.mask;
                               [// int index = hash & values.mask
                               这句代码实在计算索引值。mask的值就是Hash Table的长度。那么这个hash变量的值是如何计算的呢?
                               我们看一下hash成员变量是如何初始化的?
                               private final int hash = hashCounter.getAndAdd(0x61c88647 * 2);
                               private static AtomicInteger hashCounter = new AtomicInteger(0);
                               我们看到, hash成员变量是final的，并且是非static的。也就是说每一个ThreadLocal对象持有一个hash变量。更进一步，我们可以得到这样的结论：对于某一类的ThreadLocal变量(通俗的讲就是ThreadLocal的模版参数一样)，其实维护的是一个hash变量值，也就是说会映射到同一个索引的地方去。
                               ]// int index = hash & values.mask
                               if (this.reference == table[index]) {
                               return (T) table[index + 1];
                              }
                              [// if (this.reference == table[index])
                              在Values的实现中，table会在index保存ThreadLocal对象，而在index+1的位置保存ThreadLocal的值。为什么要这么设计呢？
                              我们先来看一下reference的定义:
                              private final Reference<ThreadLocal<T>> reference = new WeakReference<ThreadLocal<T>>(this);
                              可以看到reference是个弱引用。所以这里要先比较一下reference和table[index]. 是为了防止内存回收。
                              ]// if (this.reference == table[index])

                           } else {
                            values = initializeValues(currentThread);
                            [// values = initializeValues(currentThread)
                            Values initializeValues(Thread current) {
                                return current.localValues = new Values();
                                [// new Values()
                                Values类是ThreadLocal的一个内部类, 其实它的作用就是一个Hash Table. 我们先来看一下Values的构造函数：
                                Values() {
                                            initializeTable(INITIAL_SIZE);
                                            [// initializeTable(INITIAL_SIZE)
private void initializeTable(int capacity) {
                                                    this.table = new Object[capacity * 2];
                                                       this.mask = table.length - 1;
                                                       this.clean = 0;
                                                        this.maximumLoad = capacity * 2 / 3; // 2/3
                                                    }
                                                    initializeTable函数就是初始化Values的几个重要的成员变量。
                                                    INITIAL_SIZE是Values定义的常量。
                                                    private static final int INITIAL_SIZE = 16;
                                            ]// initializeTable(INITIAL_SIZE)
                                               this.size = 0;
                                               this.tombstones = 0;
                                            }

                                ]// new Values()
                                  }
                                  如果当前线程还没有设置过localValues,  则会创建一个Values对象，并赋值给当前线程。
                            ]// values = initializeValues(currentThread)
                           }
                           return (T) values.getAfterMiss(this);
                           [// values.getAfterMiss(this)
当第一个索引位置没有得到值的情况下或者第一次设置Values成员变量，则会调用getAfterMiss来尝试查找有冲突的情况下的值：
Object getAfterMiss(ThreadLocal<?> key) {
                                Object[] table = this.table;
                                  int index = key.hash & mask;

                                   if (table[index] == null) {
                                   [// if (table[index] == null)
                                   如果table的index索引的位置的值是null, 则说明没有发生过冲突，也就没有必要在继续查找index之后的位置
                                   ]// if (table[index] == null)
                                    Object value = key.initialValue();
                                    [// Object value = key.initialValue();
                                    这里会调用ThreadLocal的initialValue函数来初始化一个值
                                    protected T initialValue() {
                                           return null;
                                           }
                                           默认的initialValue函数的实现就是返回null
                                    ]// Object value = key.initialValue();

                                       if (this.table == table && table[index] == null) {
                                       [// if (this.table == table && table[index] == null)
                                       这里为什么还要判断一下?是为了防止在initialValue函数中改变了table, 如果发现没有改变，则设置
                                       ]// if (this.table == table && table[index] == null)
                                        table[index] = key.reference;
                                         table[index + 1] = value;
                                         size++;

                                          cleanUp();
                                          [// cleanUp()
这里还会调用cleanUp函数来清空失效的
private void cleanUp() {
                                                if (rehash()) {
[// if (rehash())
这里会先判断是否需要rehash。如果rehash了，则不必往下进行了.rehash函数的定义如下：
private boolean rehash() {
                                                            if (tombstones + size < maximumLoad) {
                                                                return false;
                                                               }
                                                               [// if (tombstones + size < maximumLoad)
                                                               tombstones + size表示目前装载的数目
                                                               ]// if (tombstones + size < maximumLoad)

                                                                int capacity = table.length >> 1;
                                                                [// int capacity = table.length >> 1
                                                                因为在hash table中, 其实是用两个位置来表示一个真正的值的。因此容量就应该为table的长度的一半。
                                                                ]// int capacity = table.length >> 1
int newCapacity = capacity;
                                                                if (size > (capacity >> 1)) {
                                                                newCapacity = capacity * 2;
                                                                }
                                                                [// if (size > (capacity >> 1))
                                                                上面这段代码是判断是否需要扩充hash table的容量。条件就是现在有效的值的个数已经超过了容量的一半。
                                                                ]// if (size > (capacity >> 1))

                                                                Object[] oldTable = this.table;
                                                               initializeTable(newCapacity);
                                                            this.tombstones = 0;
                                                            [// this.tombstones = 0;
                                                            这里是初始化了一个新的hash table
                                                            ]// this.tombstones = 0;

                                                                if (size == 0) {
                                                             return true;
                                                              }
                                                              [// if (size == 0)
                                                              如果当前没有有效的值，这直接返回
                                                              ]// if (size == 0)


                                                            for (int i = oldTable.length - 2; i >= 0; i -= 2) {
                                                            [// for (int i = oldTable.length - 2; i >= 0; i -= 2)
                                                                在这个for循环里，将老的hash table里的值拷贝到新的hash table中去
                                                               ]// for (int i = oldTable.length - 2; i >= 0; i -= 2)

                                                                Object k = oldTable[i];
                                                                  if (k == null || k == TOMBSTONE) {
                                                                    continue;
                                                                   }
                                                                   [// if (k == null || k == TOMBSTONE)
                                                                   如果发现是无效的则跳过
                                                                   ]// if (k == null || k == TOMBSTONE)

                                                                    @SuppressWarnings("unchecked")
                                                                    Reference<ThreadLocal<?>> reference = (Reference<ThreadLocal<?>>) k;
                                                                    ThreadLocal<?> key = reference.get();
                                                                    if (key != null) {
                                                                    [// if (key != null)
                                                                    如果这个ThreadLocal对象没有被回收，还是有效的，则将这个值放到新的hash table中去
                                                                    ]// if (key != null)
                                                                    add(key, oldTable[i + 1]);
                                                                    [// add(key, oldTable[i + 1])
                                                                    调用add函数来增加一个值. add函数的定义如下:
                                                                    void add(ThreadLocal<?> key, Object value) {
                                                                            for (int index = key.hash & mask;; index = next(index)) {
                                                                            [// for (int index = key.hash & mask;; index = next(index))
                                                                            for循环查找一个可以插入的位置。初始的索引是用ThreadLocal的hash变量的值和Values的成员变量mask做与运算。由此可以看出，一类的ThreadLocal的值是放在一个索引位置上的。
                                                                            next函数是计算下一个索引位置。next函数的定义如下：
private int next(int index) {
                                                                                   return (index + 2) & mask;
                                                                                    }
                                                                                    正如我们之前分析的那样，在hash table中其实是用两个位置来表示一个值的。
                                                                            ]// for (int index = key.hash & mask;; index = next(index))
                                                                                Object k = table[index];
                                                                                    if (k == null) {
                                                                                    table[index] = key.reference;
                                                                                      table[index + 1] = value;
                                                                                       return;
                                                                                 }
                                                                                 [// if (k == null)
发现一个空位置，则将值写入到这里。
                                                                                 ]// if (k == null)
                                                                               }
                                                                          }

                                                                    ]// add(key, oldTable[i + 1])
                                                                    } else {
                                                                    [// else
                                                                    这里是表示垃圾回收的情况
                                                                    ]// else
                                                                    size--;
                                                                    }
                                                             }
                                                                return true;
                                                           }

]// if (rehash())
                                                     return;
                                               }

                                                    if (size == 0) {
                                               return;
                                                    }
                                                    [// if (size == 0)
                                                    size为0表示有效的值为空，则不需要往下进行了
                                                    ]// if (size == 0)

                                                    int index = clean;
                                                    [// int index = clean
                                                    在Values类的设计中，有一个成员变量clean, 记录上次清理结束的位置。为什么要记录这个位置呢？效率会高多少呢？
                                                    ]// int index = clean
                                                  Object[] table = this.table;
                                                    for (int counter = table.length; counter > 0; counter >>= 1, index = next(index)) {
                                                       Object k = table[index];

                                                        if (k == TOMBSTONE || k == null) {
                                                           continue; // on to next entry
                                                          }

                                                            @SuppressWarnings("unchecked")
                                                            Reference<ThreadLocal<?>> reference = (Reference<ThreadLocal<?>>) k;
                                                            if (reference.get() == null) {
                                                            table[index] = TOMBSTONE;
                                                            table[index + 1] = null;
                                                             tombstones++;
                                                            size--;
                                                            }
                                                            [// if (reference.get() == null)
                                                            这里发现被垃圾回收的，则将这个位置标记为TOMBSTONE.
                                                            ]// if (reference.get() == null)
                                                        }

                                                   clean = index;
                                                   [// clean = index
                                                   记录下次清理的位置
                                                   ]// clean = index
                                               }
                                          ]// cleanUp()
                                           return value;
                                      }

                                        // The table changed during initialValue().
                                       put(key, value);
                                       [// put(key, value)
                                       如果发现在调用initialValue函数过程中, hash table已经发生了改变，则直接将这个值插入到hash table中.
                                       put函数的实现如下：
                                       void put(ThreadLocal<?> key, Object value) {
                                            cleanUp();
                                            [// cleanUp()
                                            put函数首先调用cleanUp函数
                                            ]// cleanUp()


                                              int firstTombstone = -1;
[// int firstTombstone = -1
这里用一个变量firstTombstone记录发现的第一个TOMBSTONE的位置，为什么要记录这个位置呢？因为TOMBSTONE表示被垃圾回收之后的对该位置的表示。
]// int firstTombstone = -1
                                               for (int index = key.hash & mask;; index = next(index)) {
                                                Object k = table[index];

                                                    if (k == key.reference) {
                                                   table[index + 1] = value;
                                                        return;
                                                    }
                                                    [// if (k == key.reference)
                                                    这里发现了同样一个ThreadLocal对象，则直接替换值
                                                    ]// if (k == key.reference)

                                               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;
                                                   }
                                                   [// if (k == null)
                                                   如果当前索引值位置的值为null，则说明发现了一个没有用过的位置，则不必继续搜索了。这里还会将值保存到合适的索引值的位置上去。
                                                   ]// if (k == null)

                                                   // Remember first tombstone.
                                                  if (firstTombstone == -1 && k == TOMBSTONE) {
                                                  firstTombstone = index;
                                                  }
                                             }
                                           }
                                       ]// put(key, value)
                                       return value;
                                  }

                                   int firstTombstone = -1;
                                 for (index = next(index);; index = next(index)) {
                                    Object reference = table[index];
                                        if (reference == key.reference) {
                                        return table[index + 1];
                                        }

                                        if (reference == null) {
                                        Object value = key.initialValue();

                                            if (this.table == table) {
                                          if (firstTombstone > -1 && table[firstTombstone] == TOMBSTONE) {
                                                table[firstTombstone] = key.reference;
                                                   table[firstTombstone + 1] = value;
                                                    tombstones--;
                                                  size++;

                                                   return value;
                                         }


                                           if (table[index] == null) {
                                                table[index] = key.reference;
                                                 table[index + 1] = value;
                                                size++;

                                                  cleanUp();
                                                   return value;
                                                }
                                           }

                                           put(key, value);
                                            return value;
                                       }

                                     if (firstTombstone == -1 && reference == TOMBSTONE) {
                                        firstTombstone = index;
                                      }
                                }
                                [// for (index = next(index);; index = next(index))
                                上面这段代码是不是看着很眼熟，和put函数中的实现是相似的。
                                ]// for (index = next(index);; index = next(index))
                               }

                           ]// values.getAfterMiss(this)
                      }
                    ]// if (sThreadLocal.get() != null)

                            throw new RuntimeException("Only one Looper may be created per thread");
                   }

                   sThreadLocal.set(new Looper(quitAllowed));
                   [// sThreadLocal.set(new Looper(quitAllowed))
如果sThreadLocal.get函数为null, 则说明还没有为当前线程设置过Looper对象，则这里就调用ThreadLocal的set函数来为当前线程new一个Looper对象。
我们先来看一下Looper的构造函数:
private Looper(boolean quitAllowed) {
                        mQueue = new MessageQueue(quitAllowed);
                        [// mQueue = new MessageQueue(quitAllowed)
                        在Looper类中，有一个MessageQueue的成员变量mQueue，定义如下：
                        final MessageQueue mQueue;
                        也就是说每一个Looper内部维护了一个MessageQueue。
我们看一下MessageQueue的构造函数：
MessageQueue(boolean quitAllowed) {
                               mQuitAllowed = quitAllowed;
                               mPtr = nativeInit();
                               [// mPtr = nativeInit()
这里会调用nativeInit()函数。从名字可以猜测这是个native函数。
private native static long nativeInit();
果不其然，确实是个native函数。
调用nativeInit函数其实是调用的android_os_MessageQueue.cpp(为与/home/yaojian/AndroidSource/frameworks/base/core/jni文件夹下)的android_os_MessageQueue_nativeInit函数：
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
                                            NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
                                            [// NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue()
                                           这里会创建一个C++层的NativeMessageQueue的对象。
                                           我们先来看一下NativeMessageQueue的类结构：
                                           class NativeMessageQueue : public MessageQueue
                                           class MessageQueue : public RefBase
                                           MessageQueue继承自RefBase类，由此可知可以用智能指针来管理MessageQueue类。
                                           我们再来看一下NativeMessageQueue类的构造函数:
                                           MessageQueue::MessageQueue() {
                                                }
                                                NativeMessageQueue::NativeMessageQueue() : mInCallback(false), mExceptionObj(NULL) {
                                                    mLooper = Looper::getForThread();
                                                    [// mLooper = Looper::getForThread()
                                                    在NativeMessageQueue类中也有一个Looper类型的成员变量mLooper, mLooper的定义如下：
                                                    sp<Looper> mLooper;
                                                    这里mLooper的初始化是通过Looper的getForThread函数来实现的：
                                                    sp<Looper> Looper::getForThread() {
                                                            int result = pthread_once(&gTLSOnce, initTLSKey);
                                                            [// int result = pthread_once(&gTLSOnce, initTLSKey)
                                                            这里这个pthread_once函数是干什么的呢?我也不知道，百度一下查出下面的解释:
                                                            int pthread_once(pthread_once_t *once_control, void (*init_routine) (void))
                                                            本函数使用初值为PTHREAD_ONCE_INIT的once_control变量保证init_routine()函数在本进程执行序列中仅执行一次。
                                                            也就是说pthread_once保证了initTLSKey函数之调用一次，gTLSOnce和initTLSKey的定义如下：
                                                            static pthread_once_t gTLSOnce = PTHREAD_ONCE_INIT;
                                                            initTLSKey函数的实现如下：
                                                                void Looper::initTLSKey() {
                                                                    int result = pthread_key_create(&gTLSKey, threadDestructor);
                                                                    [// int result = pthread_key_create(&gTLSKey, threadDestructor)
                                                                    在initTLSKey函数中，会调用pthread_key_create函数。那么这个pthread_key_create函数有什么作用么？我也不知道啊？还是百度一下吧：
                                                                    int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
                                                                    函数 pthread_key_create() 用来创建线程私有数据。该函数从 TSD 池中分配一项，将其地址值赋给 key 供以后访问使用。第 2 个参数是一个销毁函数，它是可选的，可以为 NULL，为 NULL 时，则系统调用默认的销毁函数进行相关的数据注销。如果不为空，则在线程退出时(调用 pthread_exit() 函数)时将以 key 锁关联的数据作为参数调用它，以释放分配的缓冲区，或是关闭文件流等。
gTLSKey和threadDestructor的定义如下：
                                                                    static pthread_key_t gTLSKey = 0;
                                                                    void Looper::threadDestructor(void *st) {
                                                                            Looper* const self = static_cast<Looper*>(st);
                                                                            if (self != NULL) {
                                                                                self->decStrong((void*)threadDestructor);
                                                                            }
                                                                        }
                                                                    ]// int result = pthread_key_create(&gTLSKey, threadDestructor)
                                                                    LOG_ALWAYS_FATAL_IF(result != 0, "Could not allocate TLS key.");
                                                                }
                                                            ]// int result = pthread_once(&gTLSOnce, initTLSKey)
                                                            LOG_ALWAYS_FATAL_IF(result != 0, "pthread_once failed");

                                                            return (Looper*)pthread_getspecific(gTLSKey);
                                                            [// return (Looper*)pthread_getspecific(gTLSKey)
                                                            在getForThread函数的最后会调用pthread_getspecific函数。那pthread_getspecific函数是干什么呢？又一次不知道，这次我决定不求助百度了，求助Google：
void *pthread_getspecific(pthread_key_t key);
函数 pthread_getspecific() 将与 key 相关联的数据读出来。返回的数据类型都是 void *，因此可以指向任何类型的数据。
                                                            ]// return (Looper*)pthread_getspecific(gTLSKey)
                                                        }
                                                        [// sp<Looper> Looper::getForThread()
                                                        通过分析getForThread函数的实现，我们发现其实这个ThreadLocal的实现是很相似的。
                                                        那为什么还在C++层在实现一套呢?现在还不知道啊.
                                                        ]// sp<Looper> Looper::getForThread()
                                                    ]// mLooper = Looper::getForThread()
                                                    if (mLooper == NULL) {
                                                    [// if (mLooper == NULL)
                                                    这里如果当前线程的Looper返回的空，则要为当前线程设置一个新的Looper对象
                                                    ]// if (mLooper == NULL)
                                                        mLooper = new Looper(false);
                                                        [// mLooper = new Looper(false)
这里会先new一个C++层的Looper对象。我们看一下Looper的构造函数:
Looper::Looper(bool allowNonCallbacks) :
                                                                    mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),
                                                                    mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {
                                                                int wakeFds[2];
                                                                int result = pipe(wakeFds);
                                                                LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);

                                                                mWakeReadPipeFd = wakeFds[0];
                                                                mWakeWritePipeFd = wakeFds[1];

                                                                result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
                                                                LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking.  errno=%d",
                                                                        errno);

                                                                result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
                                                                LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking.  errno=%d",
                                                                        errno);

                                                                mIdling = false;

                                                                // Allocate the epoll instance and register the wake pipe.
                                                                mEpollFd = epoll_create(EPOLL_SIZE_HINT);
                                                                LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);

                                                                struct epoll_event eventItem;
                                                                memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
                                                                eventItem.events = EPOLLIN;
                                                                eventItem.data.fd = mWakeReadPipeFd;
                                                                result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, & eventItem);
                                                                LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance.  errno=%d",
                                                                        errno);
                                                            }
                                                            在Looper的构造函数中，会创建两个管道:mWakeReadPipeFd和mWakeWritePipeFd。并且利用epoll机制来设置监听mWakeReadPipeFd。
                                                        ]// mLooper = new Looper(false)
                                                        Looper::setForThread(mLooper);
                                                        [// Looper::setForThread(mLooper)
                                                        当创建完C++层的Looper对象之后，就可以调用setForThread函数来将该对象设置到当前线程中去。
                                                        void Looper::setForThread(const sp<Looper>& looper) {
                                                                sp<Looper> old = getForThread(); // also has side-effect of initializing TLS

                                                                if (looper != NULL) {
                                                                    looper->incStrong((void*)threadDestructor);
                                                                }

                                                                pthread_setspecific(gTLSKey, looper.get());

                                                                if (old != NULL) {
                                                                    old->decStrong((void*)threadDestructor);
                                                                }
                                                            }
                                                        ]// Looper::setForThread(mLooper)
                                                    }
                                                }
                                            ]// NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue()
                                            if (!nativeMessageQueue) {
                                                jniThrowRuntimeException(env, "Unable to allocate native queue");
                                                return 0;
                                            }

                                            nativeMessageQueue->incStrong(env);
                                            return reinterpret_cast<jlong>(nativeMessageQueue);
                                        }
                                        当创建完C++层的NativeMessageQueue之后，就得到这个C++层的NativeMessageQueue的句柄，并赋值给成员变量mPtr. mPtr的定义如下：
                                        private long mPtr; // used by native code
                                        由此得出结论，每一个Java层的MessageQueue对象在C++曾都有一个NativeMessageQueue对象。
                               ]// mPtr = nativeInit()
                               }
                        ]// mQueue = new MessageQueue(quitAllowed)
                       mThread = Thread.currentThread();
                       }
                       [// private Looper(boolean quitAllowed)
                       首先我们注意到Looper的构造函数是private的。
                       ]// private Looper(boolean quitAllowed)

当构造完Looper对象之后，就会调用ThreadLocal的set函数来将该Looper对象保存到当前线程的ThreadLocal中去。
我们来看一下ThreadLocal类的set函数的实现:
public void set(T value) {
                       Thread currentThread = Thread.currentThread();
                           Values values = values(currentThread);
                           if (values == null) {
                           values = initializeValues(currentThread);
                           }
                           values.put(this, value);
                       }
                       [// public void set(T value)
                       set函数的实现还是比较清晰的，里面调用的函数我们之前都分析过。
                       ]// public void set(T value)

                   ]// sThreadLocal.set(new Looper(quitAllowed))
              }