ThreadLocal解析

Java同一线程进行多Java实例对象调用中，可以使用TheadLoca进行的数据传递。传递的数据在每个线程内部独享。

1、使用ThreadLocal。

public static void main(String[] args) {
        ThreadLocal<String> threadLocal = new ThreadLocal<String>();
        ThreadLocal<Integer> threadInt = new ThreadLocal<Integer>();　　
        System.out.println(threadLocal.get() + "--" + threadInt.get());
        threadLocal.set("first");
        threadInt.set(1);
        System.out.println(threadLocal.get() + "--" + threadInt.get());
        threadLocal.set("second");
        threadInt.set(2);
        
        System.out.println(threadLocal.get() + "--" + threadInt.get());
        System.out.println(threadLocal.get() + "--" + threadInt.get());
    }

 

 2、ThreadLocal类：

初始化ThreadLoca类时，构造函数为空

 /**
     * ThreadLocals rely on per-thread linear-probe hash maps attached
     * to each thread (Thread.threadLocals and
     * inheritableThreadLocals).  The ThreadLocal objects act as keys,
     * searched via threadLocalHashCode.  This is a custom hash code
     * (useful only within ThreadLocalMaps) that eliminates collisions
     * in the common case where consecutively constructed ThreadLocals
     * are used by the same threads, while remaining well-behaved in
     * less common cases.
     */
    private final int threadLocalHashCode = nextHashCode();/**
     * Creates a thread local variable.
     */
    public ThreadLocal() {
    }

 

其中变量threadLocalHashCode为不可变的final类型，表明该ThreadLocal实例中的该属性一直不能改变，该变量赋值语句为：

 /**
     * The next hash code to be given out. Updated atomically. Starts at
     * zero.
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

    /**
     * The difference between successively generated hash codes - turns
     * implicit sequential thread-local IDs into near-optimally spread
     * multiplicative hash values for power-of-two-sized tables.
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

 

使用了静态的类AtomicInteger，提供一个原子性的相加操作，保证每个线程之间的调用不会冲突，静态AtomicInteger保证每个ThreadLoca的初始化都不会得到相同的值。其中添加量为：0x61c88647(为什么是这个值？）。

ThreadLocal提供了可供调用的方法：

　　public T get()

　　public void set(T value)

　　public void remove()

先看set方法：

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

 

使用当前Thread当做Key，获取ThreadLocalMap。

/**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

 

最终返回的是Thread中的变量，threadLocals。

 /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

 

Thread类中的变量，threadLocals为每个线程私有的属性。同一个线程中的每一个ThreadLocal调用getMap(Thread t)，都会得到相同的值， ThreadLocalMap:

/**
     * ThreadLocalMap is a customized hash map suitable only for
     * maintaining thread local values. No operations are exported
     * outside of the ThreadLocal class. The class is package private to
     * allow declaration of fields in class Thread.  To help deal with
     * very large and long-lived usages, the hash table entries use
     * WeakReferences for keys. However, since reference queues are not
     * used, stale entries are guaranteed to be removed only when
     * the table starts running out of space.
     */
    static class ThreadLocalMap {
 /**
         * The initial capacity -- MUST be a power of two.
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**
         * The number of entries in the table.
         */
        private int size = 0;

        /**
         * The next size value at which to resize.
         */
        private int threshold; // Default to 0

 

ThreadLocalMap看名称以为Map的子类，其实为一个普通类，内部有一个数组  Entry[] table；

在ThreadLocal中的Set方法中，若Thread对象中的threadLocals为null（ Thread对象中该属性默认为null),则调用createMap方法：

 /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

 

new 出一个ThreadLocalMap对象，赋值给Thread的threadLocals属性，看构造方法：

/**
         * Construct a new map initially containing (firstKey, firstValue).
         * ThreadLocalMaps are constructed lazily, so we only create
         * one when we have at least one entry to put in it.
         */
        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);
        }

 

构造时需要传入两个参数， ThreadLocal与 Object作为key-value,  table数组初始化为16个， threadLocalHashCode为传入的ThreadLocal前面讲过的不变值的属性， 该值与15进行与的操作，得到ThreadLocal对应数组的index，同时设定该数组中index为new Entry对象。

/**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

 Entry继承了WeakReference， 使用一个ThreadLocal 的Weak引用，关于Java中的4种引用：

a.强引用(strong reference)： Object obj = new Object(); obj就为一个强引用，obj=null后， 该对象可能会被JVM回收

b.软引用(SoftReference): 

　　SoftReference<Object> softref = new SoftReference<Object>(obj);  

　　obj = null;

　　在内存不够用的时候，才会回收软引用的对象。

c.弱引用(WeakReference):　

　　WeakReference<Object> weakRef = new WeakReference<Object>(obj);
　　obj = null;

　　该new出来的对象没有强引用连接时，下一次GC时，就会回收该对象。

d.虚引用（PhantomReference)，它保存ReferenceQueue中的轨迹

引自：http://www.cnblogs.com/mengdd/p/3298852.html

此处使用弱引用，表明该ThreadLocal的Key转换成弱引用的对象。此处使用弱引用的好处不影响该：ThreadLocal k 的生命周期，若程序运行后，该ThreadLocal k连接的对象没有强引用后，该Entry中的Key很快会被回收掉，变为null，这样的话 （private Entry[] table;)中的该index的位置就可以被再次使用了。

其中 setThreshold(),设定数组的阀值为  len * 2 / 3,  初始化时为10.

ThreadLocalMap中的set方法：

/**
         * Set the value associated with key.
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

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

 

从key.threadLocalHashCode计算得到的第i个元素

若不为null,开始向后遍历：

　　若Entry中的k为Key,并且value也相等，则不做操作，返回。

　　若Entry中的key为null,表明该Entry可以进行下一步操作（replaceStaleEntry方法），可能是替换该Entry，也可能是查其它....

若为null，

　　new Entry，赋值到数组中，

rehash方法中，判断是否扩容数据， *2

 

get方法首先从ThreadLocalMap中查找，

/**
         * Get the entry associated with key.  This method
         * itself handles only the fast path: a direct hit of existing
         * key. It otherwise relays to getEntryAfterMiss.  This is
         * designed to maximize performance for direct hits, in part
         * by making this method readily inlinable.
         *
         * @param  key the thread local object
         * @return the entry associated with key, or null if no such
         */
        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);
        }

 

若数组中的第i个不符合，则调用getEntryAfterMiss，向后遍历。

 

 

参考：

http://www.cnblogs.com/digdeep/p/4510875.html

http://wangxinchun.iteye.com/blog/1884228