Android开发之ThreadLocal原理深入理解

[Android]ThreadLocal的定义和用途

ThreadLocal用于实现在不同的线程中存储线程私有数据的类。在多线程的环境中，当多个线程需要对某个变量进行频繁操作，同时各个线程间不需要同步，此时，各个子线程只需要对存储在当前线程中的变量的拷贝进行操作即可，程序的运行效率会很高，即所谓的空间换时间。

在开源框架EventBus和android系统的Looper类当中有运用到ThreadLocal进行线程局部数据的存储，android版的ThreadLocal和java原生的ThreadLocal有一定的差别，android版的进行了一些优化设计,通过内部类Values中的Object数组来存储ThreadLocal的弱引用和线程的局部数据对象；而java版的是以MAP的方式来存储。

[Android]ThreadLocal的基本使用

ThreadLocal的使用很简单，定义一个全局的ThreadLocal对象，在线程中通过get()方法得到当前线程的局部数据进行操作。

ThreadLocal<ClassType> storageDataThreadLocal = new ThreadLocal<ClassType>(){
    @Override
    protected ClassType initialValue() {
        return new ClassType();
    }
};

ClassType为自定义的数据类，实例化ThreadLocal对象过程中如果没有重写initialValue方法则第一次调用get方法会返回空，这里需要注意。

[Android]ThreadLocal实现线程数据拷贝的原理

我们关注最多的应该就是ThreadLocal如何实现线程的局部数据存储，通过分析源码可以得到最终的答案。

我们直接分析get函数：

/**
 * Returns the value of this variable for the current thread. If an entry
 * doesn't yet exist for this variable on this thread, this method will
 * create an entry, populating the value with the result of
 * {@link #initialValue()}.
 *
 * @return the current value of the variable for the calling thread.
 */
@SuppressWarnings("unchecked")
public T get() {
    // Optimized for the fast path.
    //通过native方法得到代码当前执行的线程对象
    Thread currentThread = Thread.currentThread();
    //得到当前线程的Values类型对象
    Values values = values(currentThread);
    if (values != null) {
    	  //得到对象数组table，用来存储当前ThreadLocal对象的弱引用
    	  //和当前线程的局部数据对象引用
        Object[] table = values.table;
        //得到用于存储ThreadLocal弱引用的散列值索引
        int index = hash & values.mask;
        //指向到对象相同，则返回其引用
        if (this.reference == table[index]) {
            return (T) table[index + 1];
        }
    } else {
    	  //新建values对象赋给当前线程对象的localValues引用
        values = initializeValues(currentThread);
    }

    return (T) values.getAfterMiss(this);
}

如果当前线程对象内的Values对象中有存储和当前ThreadLocal对象的reference属性是同一个对象的引用则返回此线程的本地数据，即变量在线程的本地拷贝。

否则在当前线程内部创建一个Values对象，通过Values.getAfterMiss将ThreadLocal类的initialValue方法得到的本地数据存储到当前线程对象内部并返回；initialValue是protected方法，如果子类没有重写，则默认返回空。

静态内部类Values的getAfterMiss函数：

/**
* Gets value for given ThreadLocal after not finding it in the first
* slot.
*/
Object getAfterMiss(ThreadLocal<?> key) {
	Object[] table = this.table;
	//通过散列算法得到ThreadLocal的first slot的索引值
   int index = key.hash & mask;

   // If the first slot is empty, the search is over.
   if (table[index] == null) {
   	 //如果first slot上没有存储 则将ThreadLocal的弱引用和本地数据
   	 //存储到table数组的相邻位置并返回本地数据对象引用
       Object value = key.initialValue();

       // If the table is still the same and the slot is still empty...
       if (this.table == table && table[index] == null) {
             table[index] = key.reference;
             table[index + 1] = value;
             size++;

             cleanUp();
             return value;
         }

         // The table changed during initialValue().
         //遍历table数组，根据不同判断将ThreadLocal的
         //弱引用和本地数据对象引用存储到table数组的相应位置
         put(key, value);
         return value;
     }

     // Keep track of first tombstone. That's where we want to go back
     // and add an entry if necessary.
     int firstTombstone = -1;

     // Continue search.
     for (index = next(index);; index = next(index)) {
         Object reference = table[index];
         if (reference == key.reference) {
             return table[index + 1];
         }

         // If no entry was found...
         if (reference == null) {
             Object value = key.initialValue();

             // If the table is still the same...
             if (this.table == table) {
                 // If we passed a tombstone and that slot still
                 // contains a tombstone...
                 if (firstTombstone > -1
                         && table[firstTombstone] == TOMBSTONE) {
                     table[firstTombstone] = key.reference;
                     table[firstTombstone + 1] = value;
                     tombstones--;
                     size++;

                     // No need to clean up here. We aren't filling
                     // in a null slot.
                     return value;
                 }

                 // If this slot is still empty...
                 if (table[index] == null) {
                     table[index] = key.reference;
                     table[index + 1] = value;
                     size++;

                     cleanUp();
                     return value;
                 }
             }

             // The table changed during initialValue().
             put(key, value);
             return value;
         }

         if (firstTombstone == -1 && reference == TOMBSTONE) {
             // Keep track of this tombstone so we can overwrite it.
             firstTombstone = index;
         }
     }
 }

getAfterMiss函数根据不同的判断将ThreadLocal的弱引用和当前线程的本地对象以类似MAP的方式，存储在table数组的相邻位置，其中其散列的索引hash值是通过hashCounter.getAndAdd(0x61c88647 * 2)算法来得到。

set函数：

/**
 * Sets the value of this variable for the current thread. If set to
 * {@code null}, the value will be set to null and the underlying entry will
 * still be present.
 *
 * @param value the new value of the variable for the caller thread.
 */
public void set(T value) {
    Thread currentThread = Thread.currentThread();
    //得到当前线程的本地Values对象
    Values values = values(currentThread);
    if (values == null) {
    	  //为空则新建Values对象
        values = initializeValues(currentThread);
    }
    //将当前ThreadLocal对象引用和本地数据存储到
    //当前ThreadLocal的内部Values对象的table数组当中
    //当调用get方法时，获得的即是当前线程的本地数据
    values.put(this, value);
}

[Android]关于ThreadLocal内存泄漏的问题

在其他的博文中有说到，java版的ThreadLocal“value值因为存在一条从current thread连接过来的强引用,只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收.”.

在android版的ThreadLocal中value值不存在强引用，故在table数组中的指定位置置为null，本地数据则没有存在指向其的引用，当GC回收的时候会清理掉。

[Android]ThreadLocal总结

ThreadLocal实现线程本地存储的原理是比较清晰的，即在当前线程中调用get方法时，通过ThreadLocal的initialValue方法创建当前线程的一个本地数据拷贝，将此拷贝添加到当前线程本地数据的table数组当中；或者在调用set方法时，将当前线程的本地数据存储到当前线程的table数组中.当前线程通过调用ThreadLocal对象的get方法即得到当前线程本地数据对象。