关于ThreadLocal类的理解

在多线程的环境下，共享资源的访问就变得不安全了，ThreadLocal类可以保证每个线程使用的都是共享资源的一个副本，从而保证线程之间的资源都是独立的，确保资源的线程安全

源码片段（带官方注释）：

/**
     * Returns the current thread's "initial value" for this
     * thread-local variable.  This method will be invoked the first
     * time a thread accesses the variable with the {@link #get}
     * method, unless the thread previously invoked the {@link #set}
     * method, in which case the <tt>initialValue</tt> method will not
     * be invoked for the thread.  Normally, this method is invoked at
     * most once per thread, but it may be invoked again in case of
     * subsequent invocations of {@link #remove} followed by {@link #get}.
     *
     * <p>This implementation simply returns <tt>null</tt>; if the
     * programmer desires thread-local variables to have an initial
     * value other than <tt>null</tt>, <tt>ThreadLocal</tt> must be
     * subclassed, and this method overridden.  Typically, an
     * anonymous inner class will be used.
     *
     * @return the initial value for this thread-local
*/
protected T initialValue() {
        return null;
}

1. 当线程第一次调用get()并且之前没有调用过set()方法时，就会调用此方法
2. 若调用了remove()方法，则下次调用get()方法时也会调用此方法
3. 一般需要重写此方法

/**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
*/
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t); //获取当前线程的ThreadLocalMap属性
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this); //从ThreadLocalMap中根据key（ThreadLocal对象）获取资源副本
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue(); //没值，则初始化资源副本
    }

/**
     * 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;
    }

/**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
*/
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value); //key： 当前的ThreadLocal对象  value: 资源副本
        else
            createMap(t, value);
        return value;
    }

 

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

1. 获取当前线程中保存的资源副本
2. Thread类里有一个threadLocals属性，由ThreadLocal类来维护，作用是存储ThreadLocal对象和资源副本的key-value键对值
　　ThreadLocal.ThreadLocalMap threadLocals = null;

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

 

/**
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * <tt>initialValue</tt> method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

 

总结：

　　1. Thread类中有一个ThreadLocal.ThreadLocalMap threadLocals属性，供ThreadLocal来维护并且保存资源副本

　　2. ThreadLocal保证线程安全的原理就是，在线程中保存一份共享资源的副本，保存的形式是key-value键值对(key是当前ThreadLocal对象，value是资源副本)

　　3. 一个线程的threadLocals属性中可能有多个ThreadLocal对象，每个ThreadLocal对象又对应多个不同的资源

示例代码：

public class Main {
    public static void main(String[] args){
        SquNum sn = new SquNum(); //多个线程使用同一个对象

        Thread t1 = new Thread(new ThreadTemp(sn));
        Thread t2 = new Thread(new ThreadTemp(sn));
        Thread t3 = new Thread(new ThreadTemp(sn));

        t1.start();
        t2.start();
        t3.start();

        System.out.println(sn.getNextNum());
    }
}

class SquNum{
    private ThreadLocal<Common> seqNum = new ThreadLocal<Common>(){
        @Override
        protected Common initialValue() { //重写initialValue方法
            return new Common();
        }
    };

    public int getNextNum(){
        seqNum.get().setCount(seqNum.get().getCount() + 1); //调用ThreadLocal的get, set方法
        seqNum.set(seqNum.get());
        return seqNum.get().getCount();
    }
}

class ThreadTemp implements Runnable{
    private SquNum sn;

    public ThreadTemp(SquNum sn) {
        this.sn = sn;
    }
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("Thread: [" + Thread.currentThread().getName() + "] sn: [" + sn.getNextNum() + "]");
        }
    }
}

class Common{
    private Integer count = 0;

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }
}

 

输出：

Thread: [Thread-0] sn: [1]
Thread: [Thread-0] sn: [2]
Thread: [Thread-0] sn: [3]
Thread: [Thread-1] sn: [1]
Thread: [Thread-1] sn: [2]
Thread: [Thread-1] sn: [3]
1
Thread: [Thread-2] sn: [1]
Thread: [Thread-2] sn: [2]
Thread: [Thread-2] sn: [3]

 

解释：

　　1. 从输出可以看到，每一个线程(包括主线程)使用的Common对象资源没有相互影响

　　2. 上边代码中只new了一个ThreadLocal对象，所有线程共用一个ThreadLocal对象，也就是说，所有线程中的ThreadLocalMap中的key都是同一个ThreadLocal对象

　　3. 虽然共享同一个ThreadLocal对象，但资源并不会共享，因为在通过sn.getNextNum()时，会调用ThreadLocal的seqNum.get()方法，此时在当前线程中将ThreadLocal对象作为key在ThreadLocalMap对象里查找value，发现value为空，就会调用initialValue()，重新new一个Common对象，所以资源并不会共享。

　　4. 若需要线程之间资源访问的安全，则需要在线程中通过ThreadLocal来访问资源，并保证重写了ThreadLocal的initialValue()方法，此方法返回一个新的资源副本。