ThreadLocal失效

         在JDK中，解决线程冲突问题，有两种解决方案：l  给临界区加锁；l  本地化临界区。

第一种解决方案的典型代表是Synchonized。第二种的典型代表是ThreadLocal。而CopyOnWrite是这两种方案的融合。

         ThreadLocal为每个线程的并发访问数据创建一个副本，通过对副本的操作来隔离临界区的污染。虽然增加了内存空间的消耗，但大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。

         当然ThreadLocal不能完全解决并发的问题，因为它只是隔离了临界区，抛开了临界区的同步问题，导致多个副本的存在。所以使用的时候要因地制宜，符合自身的逻辑。

Demo

         ThreadLocal的使用很简单，如下所示，先声明一个ThreadLocal的私有变量。然后在线程启动的时候赋值set()，在使用的时候再get()出来。

private ThreadLocal local = new ThreadLocal();
public void run() {
    local.set(objLocal);
    // ......
    local.get();
           

         也可以通过覆盖初始值的方法initialValue()来实现赋值。

private ThreadLocal local = new ThreadLocal() {
    @Override
    protected ObjectinitialValue() {
        // ......
        return XXX;
    }
};
           

Code

         那ThreadLocal是如何能实现本地化临界区的功能呢？我们到JDK一看究竟。

         在线程类Thread中，通过一个Map属性threadLocals来存放临界区的数据。我暂且称之为本地数据区。   这个Map的key为ThreadLocal实例，value为临界区的数据值。

         这个ThreadLocalMap没有实现Map接口，但是也用到了散列表来组织数据。

ThreadLocal.ThreadLocalMap threadLocals = null;
           

         接着，我们看到ThreadLocal取值get()时候，需要传入当前线程t来获取本地数据区t.threadLocals。获取到数据区后，使用ThreadLocal实例作为key来取值。

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
           

         同样，赋值set()也是差不多的逻辑。如果t.threadLocals不存在就新建一个ThreadLocalMap对象。

         这里有个需要注意的点，获取本地数据区是要传入当前线程的，因为threadLocals是挂在具体的Thread对象上。所以set()需要在线程运行的时候进行，否则就会导致传入主线程，取到了主线程的本地数据区。

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
           

         最后，我们发现ThreadLocal赋值到本地数据区的时候，会创建一个Entry来存放：key为ThreadLocal实例，value为副本值。这里其实只是把value的值赋过来，没有做clone的处理。

         所以需要加倍注意的是，此处只是值拷贝，没做clone(深度拷贝)。如果传进来的是个引用，就不能做到隔离了。

static class Entry extendsWeakReference<ThreadLocal> {
        Object value;
        Entry(ThreadLocal k, Object v) {
            super(k);
            value = v;
        }
    }
           

P.S 隔离失效

         从上面ThreadLocal源码可以看出：

1)      ThreadLocal赋初始值的时候，需要在线程运行中，即run()中，否则ThreadLocalMap会挂错线程；

2)      使用ThreadLocal隔离的值不能是引用，否则隔离的只是引用，而引用所指向的对象则隔离失败；

3)      本地数据区ThreadLocalMap是挂在Thread对象上的，所以要注意线程复用(线程池)所带来的污染。

set引用

         下面程序先创建一个SHARE_LIST作为临界区，然后创建两个线程同时去做修改。

         给每个线程引入ThreadLocal属性试图本地化SHARE_LIST来隔离多线程的冲突。

         根据ThreadLocal的设计初衷，应该是在各个Thread创建自己的本地数据区，互不影响。后来却发现SHARE_LIST被污染了，所有线程的修改都写入了同一个SHARE_LIST。最后，主线程和另外两个线程输出的结果都是一样的。

         这里ThreadLocal只是本地化(隔离)了引用值，而没有本地化引用的对象本身，所以出现了这种现象。

public static List<String>SHARE_LIST = new CopyOnWriteArrayList<String>();
    public static void main(String[]args) throws Exception {
        SHARE_LIST.add("Int");
        System.out.println("Change before : " + SHARE_LIST);
        new MyThread2("Tom").start();
        new MyThread2("Jack").start();
        System.out.println("Change after :");
 
        Thread.currentThread().sleep(500);
        System.out.println(Thread.currentThread() + ":" + SHARE_LIST);
    }
 
    static class MyThread2 extends Thread {
        privateThreadLocal<List<String>> local = new ThreadLocal<List<String>>();
        private String name;
 
        public MyThread2(Stringname) {
            this.name = name;
        }
 
        @Override
        public void run() {
            local.set(SHARE_LIST);
            local.get().add(name);   // Change the parameter locally.
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread() + ":" + local.get());
        }
    }
           

挂错线程

         把上面的代码稍作修改，把ThreadLocal的赋初始值放在创建线程实例的构造函数中。执行程序后，发现获取本地数据区local.get()的时候抛出了NullPointerException。

         这是因为线程创建的时候还在主线程main中，这个时候赋值set()就会把数据放到了main的本地数据区；而到了子线程run()的时候，获取本地数据区get()取的是子线程的，所以就会抛空指针。

public static void main(String[]args) throws InterruptedException {
        SHARE_LIST.add("Int");
        System.out.println("Change before : " + SHARE_LIST);
        new MyThread3("Tom", SHARE_LIST).start();
        new MyThread3("Jack", SHARE_LIST).start();
        System.out.println("Change after :");
 
        Thread.currentThread().sleep(500);
        System.out.println(Thread.currentThread() + ":" + SHARE_LIST);
    }
 
    static class MyThread3 extends Thread {
        privateThreadLocal<List<String>> local = new ThreadLocal<List<String>>();
        private String name;
 
        public MyThread3(String name, List<String>list) {
            this.name = name;
            local.set(list);
        }
 
        @Override
        public void run() {
            local.get().add(name); // Changethe parameter locally.
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread() + ":" + local.get());
        }
    }