Ａndroid ThreadLocal理解

Android ThreadLocal与Java ThreadLocal实现并不相同。

在Android消息循环一文中http://blog.csdn.net/zyfzhangyafei/article/details/62882117，提到了ThreadLocal,这个叫做　线程局部变量　的东西。

看一个实例：

package test;import test.*;public class Test {static final    ThreadLocal<ThreadValue> mThreadLocal = new ThreadLocal<ThreadValue>();    /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        ThreadValue threadValue = new ThreadValue("主线程");         mThreadLocal.set(threadValue);         System.out.print("in main thread : mThreadLocal:" + mThreadLocal +"\n");         System.out.print("in main thread : 名字:" + mThreadLocal.get().name +"\n");         mThreadLocal.get().print();         new Thread(new Runnable() {                @Override                public void run() {                    ThreadValue childThreadValue = new ThreadValue("子线程");                     mThreadLocal.set(childThreadValue);                     System.out.print("in child thread : mThreadLocal:" + mThreadLocal +"\n");                     System.out.print("in child thread : 名字:" + mThreadLocal.get().name +"\n");                     mThreadLocal.get().print();                }              }).start();    }}package test;public class ThreadValue  {      String name;      public ThreadValue() {      }      public ThreadValue(String name) {          this.name=name;      }      public void print()      {          System.out.print("this = " + this+" \n");       }    }

然后编译：javac test/*.java
运行：java test.Test
输出：
in main thread : mThreadLocal:java.lang.ThreadLocal@788bf135
in main thread : 名字:主线程
this = test.ThreadValue@2b890c67
in child thread : mThreadLocal:java.lang.ThreadLocal@788bf135
in child thread : 名字:子线程
this = test.ThreadValue@4f93b604

可以看出由于mThreadLocal定义为静态最终变量，所以在主线程和子线程中，mThreadLocal都是同一个实例。
但是在两个线程中调用mThreadLocal.get()，得到的ThreadValue对象却并不相同。
这是因为mThreadLocal.get()，取到的对象是线程内的局部变量，相互之间并不干扰。

在android中Handler.java中，通过Looper.myLooper()获得了当前线程绑定的消息泵Looper：

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

就是通过种方式来实现的。

我们就从这个使用过程来跟踪它的实现和原理。
在Looper.java中：
static final ThreadLocal sThreadLocal = new ThreadLocal();
定义了一个静态的最终的变量sThreadLocal
然后在Loop.prepare中，new了一个Looper，并设置进sThreadLocal中：

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

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

这里的values 是返回了current.localValues：

Values values(Thread current) {        return current.localValues;    }

这个current.localValues定义在Thread.java 中

public class Thread implements Runnable {...    ThreadLocal.Values localValues;...}

在最初的时候values是null，所以调用initializeValues函数：

    Values initializeValues(Thread current) {        return current.localValues = new Values();    }

这里new 的Values对象，被赋给了current.localValues，结合前面values(Thread current)函数，可知会为每个线程创建属于自己的Values对象。再看与set对应的get函数:

    public T get() {        // Optimized for the fast path.        Thread currentThread = Thread.currentThread();        Values values = values(currentThread);        if (values != null) {            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);    }

get函数是通过获得当前线程的ThreadLocal.Values，找到对应的存储在values.table里的数据的。所以这就达到了各个线程的数据相互独立的目的，这就是所谓的线程局部变量。
接着来看ThreadLocal.Values是个什么东西：

        Values() {            initializeTable(INITIAL_SIZE);//INITIAL_SIZE的值是16            this.size = 0;//有效元素个数            this.tombstones = 0;//“废弃”元素个数        }        private void initializeTable(int capacity) {            this.table = new Object[capacity * 2];//capacity　默认为16            this.mask = table.length - 1;//mask 默认是31，就是2^n-1,这里的n指位数。转换成二进制就明白了11111,也就是这个掩码用来取最后的五个位            this.clean = 0;//这个是用来保存下一个清除的位置            this.maximumLoad = capacity * 2 / 3; // 2/3　//maximumLoad　最大元素保存数（包括“废弃”加上有效元素） 默认是10。由于要取偶数，所以总容量需要除以2再减1，也就是默认15，但为什么是除以3，也就是10，这个没有理解。        }

new 了一个Values对象，并且初始化了一个16*2的object数组table，然后设置了相关的变量。size指的是当前table中有效元素的个数，tombstones是墓碑的意思，在这里代表已经被移除掉的元素。size＋tombstones的个数要小于maximumLoad。table是一个object数组，这里是当做map来用。mask是用来计算元素保存的下标的，是一个掩码。clean是用来记录下一个清除的位置的。maximumLoad就是总的存储元素的阀值。

最后调用了Values.set函数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) { // ..........<1>                    // Replace existing entry.                    table[index + 1] = value;／／覆盖原来的value                    return;                }                if (k == null) {                    if (firstTombstone == -1) {// ..........<2>                        // Fill in null slot.                        table[index] = key.reference;                        table[index + 1] = value;                        size++;                        return;                    }                        //...........<3>                    // 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) {//...........<4>                    firstTombstone = index;//记住第一个“墓碑”的位置                }            }        }

1、第一次调用这个put函数时，Object k = table[index];这里的k取出来的是null，且firstTombstone的值为-1，所以走的是<2>。table的长度一定是2的倍数，原因在这里可以看出：数组的前一个单元存储的是key，后一个单元存储的是value。由此可见，存储一组数据需要两个单元。

另外这里的key存储的是一个弱引用key.reference，这样ＧＣ的时候可以直接回收该对象。

2、当再次调用put函数时,如果key中指向的弱引用指向的对象并没有被回收，就会走<1>，这时候就是覆盖原来的value.

3、当调用了Values.remove函数后：

        void remove(ThreadLocal<?> key) {            cleanUp();            for (int index = key.hash & mask;; index = next(index)) {//key.hash & mask： mask是31即2^n - 1也即11111，也就是即key.hash的后n位，这里默认n=5，这里的目的是为了将数据尽量分散的存储在数组当中                Object reference = table[index];                if (reference == key.reference) {                    // Success!                    table[index] = TOMBSTONE;//将key置为了TOMBSTONE                    table[index + 1] = null;//将value置为null                    tombstones++;//“墓碑”增加                    size--;//有效元素减少                    return;                }                if (reference == null) {                    // No entry found.                    return;                }            }        }

key.hash & mask： mask是31即2^n - 1也即11111，也就是即key.hash的后n位，这里默认n=5，这里的目的是为了将数据尽量分散的存储在数组当中。0x61c88647据说是个很神奇的数，产生的数字分布很均匀。这里用来构造hash表。

可以看出将key置为了TOMBSTONE，value置为null，所以k == TOMBSTONE成立，如果是第一个元素的话，firstTombstone == -1成立，所以在调用remove后，再调用put时就走<4>。
并接着循环遍历，直到k == null，即一个空闲的单元。然后走<3>，将数据放在第一个被“废弃”的位置，并结束遍历。（为什么？难道说这个table里一定要空一个位置出来？没理解!）

接着往下看。在remove的第一行代码，调用了cleanUp()函数。
cleanUp()函数在最开始调用了rehash()函数，我们先看rehash()函数：

        private boolean rehash() {            if (tombstones + size < maximumLoad) {//如果被“废弃”的加上有效元素小于阀值（默认是10），返回false                return false;            }            int capacity = table.length >> 1;            int newCapacity = capacity;            if (size > (capacity >> 1)) {//如果有效元素的个数超过一半                newCapacity = capacity * 2;//容量增加一倍            }            Object[] oldTable = this.table;            // Allocate new table.            initializeTable(newCapacity);//重新开壁了一个原来容量两倍的数组            // We won't have any tombstones after this.            this.tombstones = 0;// 将“废弃”数清0            // If we have no live entries, we can quit here.            if (size == 0) {                return true;            }            // Move over entries.            for (int i = oldTable.length - 2; i >= 0; i -= 2) {                Object k = oldTable[i];                if (k == null || k == TOMBSTONE) {//空单元和“废弃”的单元丢弃                    // Skip this entry.                    continue;                }                // The table can only contain null, tombstones and references.                @SuppressWarnings("unchecked")                Reference<ThreadLocal<?>> reference                        = (Reference<ThreadLocal<?>>) k;                ThreadLocal<?> key = reference.get();                if (key != null) {//如果对象没有被回收                    // Entry is still live. Move it over.                    add(key, oldTable[i + 1]);//添加到新的数组当中                } else {                    // The key was reclaimed.                    size--;//有效元素减少                }            }            return true;        }

可以看出rehash()是用来重新调整数组中的元素的，有必要的时候将容量扩大一倍（重新构建一个新的hash表）.

我们来看看cleanUp()这个函数：

        private void cleanUp() {            if (rehash()) {                // If we rehashed, we needn't clean up (clean up happens as                // a side effect).                return;            }            if (size == 0) {                // No live entries == nothing to clean.                return;            }            // Clean log(table.length) entries picking up where we left off            // last time.            int index = clean;//clean默认为0            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                }                // The table can only contain null, tombstones and references.                @SuppressWarnings("unchecked")                Reference<ThreadLocal<?>> reference                        = (Reference<ThreadLocal<?>>) k;                if (reference.get() == null) {//已经被回收的对象                    // This thread local was reclaimed by the garbage collector.                    table[index] = TOMBSTONE;//置为“废弃”单元                    table[index + 1] = null;                    tombstones++;                    size--;                }            }            // Point cursor to next index.            clean = index;//指向下一个要清理的数据        }

cleanUp函数的目的是对table做一个整理，交将已经回收的单元做一个标识，置为“废弃”单元，将将对应的值释放掉。

总结一下：
1、ThreadLocal之所以能达到“线程局部变量”的目的，是因为每个线程都有一个Thread.localValues变量，如果使用了ThreadLocal，这个变量会指向一个Values对象，这个Values对象就是线程独有的。

2、Values中有一个table的成员变量，table是一个Object数组，但是是以map的方式来存储的。偶数单元存储的是key，key的下一个单元存储的是对应的value，所以每存储一个元素，需要两个单元，这就是为什么容量一定是2的倍数。这里的key存储的是ThreadLocal实例的弱引用。

3、get 的时候是用的斐波拉契散列寻址的方式。（寻址的问题，后面再单独写一章）

最后记录一个点：
由于Values.table.key虽然是弱引用能够被ＧＣ所回收，但是Values本身被当前线程current thread所引用，于是Values.table.value所保存的对象并不能被ＧＣ所回收。只有当前thread结束以后, current thread就不会存在栈中，这个引用才会中断，才能被ＧＣ所回收。

一般的情况下，这种现象的存在，并不能叫做内存泄露，只能说内存的回收被delay了。
但是如果是在线程池的情况下，这种情况就比较严重了。因为线程池的情况下线程本身不会被销毁，而是返回到线程池中等待再次被启用，所以这个内存一直被占用，我们假设这个线程池有100个线程，而且保存在这个Values里的是图片类的大内存占用的数据的话，那这个内存就很可观了。

所以我们在使用完线程后，在交还回线程池之前，应该要调用threadlocal的remove函数，将不需要的数组中数据释放掉。