ThreadLocal的一点理解

最近在看Spring，了解到spring中绝大部分的bean都可以声明为singleton的，是因为spring对bean中的一些非线程安全的状态采用ThreadLocal来处理，让他们变成了线程安全的bean。例如在TranscationSynchronizationManaer中：

public abstract class TranscationSynchronizationManager{
    //用于保存每个事务线程对应的connection或者session等资源
    private static final ThreadLocal resources = new ThreadLocal();
    //用于保存每个事务线程对应事务的名称
    private static final ThreadLocal currentTranscationName = new ThreadLocal();
    //用于保存每个事务线程对应事务的read-only状态
    private static final ThreadLocal currentTranscationReadOnly = new ThreadLocal();
    .....
}

ThreadLocal 是如何存储变量的呢？首先在Thread类中有一个变量threadLocals，类型为ThreadLocal中的静态内部类ThreadLocalMap,该变量是存储的实体。

    ThreadLocal.ThreadLocalMap threadLocals = null;

    ThreadLocalMap是ThreadLocal中的静态内部类，构造函数声明如下：

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

从上面的代码可以看到，ThreadLocalMap有点类似于HashMap的存储。键为TheadLocal类型的变量，值为所要存储的与该ThreadLocal类型的变量的绑定值。table是一个数组，存储的变量类型为Entry，但是Entry中并没有定义用于解决hash冲突的next指针，这里采用的是线性探测再散列的方法解决冲突。
然后，就可以在ThreadLocal中可以调用get()方法来获取指定的值。

//ThreadLocal中的方法
public T get() {
        Thread t = Thread.currentThread();//获取到当前的线程
        ThreadLocalMap map = getMap(t);//获取到当前线程对象中存储的ThreadLocalMap变量
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);//键为当前的ThreadLocal对象
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
    //THreadLocalMap中的方法
    private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);//这里就是尝试寻找下一个位置的元素
        }

如果要往ThreadLocalMap中插入值

public void set(T value) {//THreadLocal中的方法
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);//获取当前线程对象中存储的ThreadLocalMap对象
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    //ThreadLocalMap中的变量
private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

另外附线程安全的几个层次：
1. 使用无状态对象
2. 线程封闭
3. 采用同步技术
其中线程封闭又包括 ad-hoc线程封闭，栈封闭，使用ThreadLocal