多线程进阶InheritableThreadLocal

上篇说的是ThreadLocal，如果对ThreadLocal足够了解的话，InheritableThreadLocal也很好理解。InheritableThreadLocal类继承于ThreadLocal类，所以它具有ThreadLocal类的特性，但又是一种特殊的ThreadLocal，其特殊性在于InheritableThreadLocal变量值会自动传递给所有子线程，而普通ThreadLocal变量不行，那么子线程是否可以修改InheritableThreadLocal变量值然后反向传递给主线程了，答案是对于引用类型来说，其内部的属性改变是可以传递给主线程的，对于基本数据类型以及String,Integer等包装类型来说是不可以的，原因是子线程的变量来源于父线程变量的浅拷贝，首先来个例子：

package com.lzzl.thread10;public class Person {    private String name;    private int id;    @Override    public String toString() {        return "Person [name=" + name + ", id=" + id + "]";    }    public Person(){    }    public Person(String name, int id) {        super();        this.name = name;        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }}

package com.lzzl.thread10;public class MyThreadLocal extends ThreadLocal<Person>{    @Override    protected Person initialValue() {        // TODO Auto-generated method stub        return new Person("初始值",0);    }}package com.lzzl.thread10;public class MyInheritableThreadLocal extends InheritableThreadLocal<Person>{    @Override    protected Person initialValue() {        // TODO Auto-generated method stub        return new Person("in初始值",0);    }}package com.lzzl.thread10;public class Tools {    public static MyThreadLocal t1 = new MyThreadLocal();    public static MyInheritableThreadLocal t2 = new MyInheritableThreadLocal();}

package com.lzzl.thread10;public class Run {        public static void main(String[] args) {            Tools.t2.set(new Person("inmain",1));//执行步骤1            new Thread(new Runnable() {                   public void run() {                    System.out.println("线程A获t2得的值"+Tools.t2.get());//执行步骤4                    Tools.t2.get().setName("---main");//执行步骤5，这里修改了存入的变量的属性                    System.out.println("线程A修改t2的值");//执行步骤6                    System.out.println("线程A获得t2的值"+Tools.t2.get());//执行步骤7                }            },"A").start();            System.out.println("main线程获得t2的值"+Tools.t2.get());//执行步骤2            try {                Thread.sleep(3000);//执行步骤3            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            System.out.println("main线程获得t2的值"+Tools.t2.get());        }}

输出
线程A获t2得的值Person [name=inmain, id=1]
线程A修改t2的值
main线程获得t2的值Person [name=inmain, id=1]
线程A获得t2的值Person [name=—main, id=1]
main线程获得t2的值Person [name=—main, id=1]

到这里已经看出的子线程修改变量的属性反映到了主线程之中

来看看其原理吧，贴上源代码

public class InheritableThreadLocal<T> extends ThreadLocal<T> {    /**     * Computes the child's initial value for this inheritable thread-local     * variable as a function of the parent's value at the time the child     * thread is created.  This method is called from within the parent     * thread before the child is started.     * <p>     * This method merely returns its input argument, and should be overridden     * if a different behavior is desired.     *//这里可以对从父线程得到的变量进行自己的改变     * @param parentValue the parent thread's value     * @return the child thread's initial value     */    protected T childValue(T parentValue) {        return parentValue;    }    /**     * Get the map associated with a ThreadLocal.     *     * @param t the current thread     */    ThreadLocalMap getMap(Thread t) {       return t.inheritableThreadLocals;    }    /**     * Create the map associated with a ThreadLocal.     *     * @param t the current thread     * @param firstValue value for the initial entry of the table.     * @param map the map to store.     */    void createMap(Thread t, T firstValue) {        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);    }}

publicclass Thread implements Runnable {ThreadLocal.ThreadLocalMap threadLocals = null;ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;public Thread() {        init(null, null, "Thread-" + nextThreadNum(), 0);    } private void init(ThreadGroup g, Runnable target, String name,                      long stackSize) {        if (name == null) {            throw new NullPointerException("name cannot be null");        }        Thread parent = currentThread();//parent为当前线程        SecurityManager security = System.getSecurityManager();        if (g == null) {            /* Determine if it's an applet or not */            /* If there is a security manager, ask the security manager               what to do. */            if (security != null) {                g = security.getThreadGroup();            }            /* If the security doesn't have a strong opinion of the matter               use the parent thread group. */            if (g == null) {                g = parent.getThreadGroup();            }        }        /* checkAccess regardless of whether or not threadgroup is           explicitly passed in. */        g.checkAccess();        /*         * Do we have the required permissions?         */        if (security != null) {            if (isCCLOverridden(getClass())) {                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);            }        }        g.addUnstarted();        this.group = g;        this.daemon = parent.isDaemon();        this.priority = parent.getPriority();        this.name = name.toCharArray();        if (security == null || isCCLOverridden(parent.getClass()))            this.contextClassLoader = parent.getContextClassLoader();        else            this.contextClassLoader = parent.contextClassLoader;        this.inheritedAccessControlContext = AccessController.getContext();        this.target = target;        setPriority(priority);        if (parent.inheritableThreadLocals != null)//拷贝父线程的inheritableThreadLocals            this.inheritableThreadLocals =                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);        /* Stash the specified stack size in case the VM cares */        this.stackSize = stackSize;        /* Set thread ID */        tid = nextThreadID();    }static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {        return new ThreadLocalMap(parentMap);    }     static class ThreadLocalMap {        static class Entry extends WeakReference<ThreadLocal> {            /** The value associated with this ThreadLocal. */            Object value;            Entry(ThreadLocal k, Object v) {                super(k);                value = v;            }        }        private ThreadLocalMap(ThreadLocalMap parentMap) {//拷贝父线程中的map            Entry[] parentTable = parentMap.table;            int len = parentTable.length;            setThreshold(len);            table = new Entry[len];            for (int j = 0; j < len; j++) {                Entry e = parentTable[j];                if (e != null) {                    ThreadLocal key = e.get();                    if (key != null) {                    //这里可以看出来只是进行了浅拷贝，这里就是上面样例中子线程改变变量属性，父线程的                    //变量属性改变的原因了                        Object value = key.childValue(e.value);                        Entry c = new Entry(key, value);                        int h = key.threadLocalHashCode & (len - 1);                        while (table[h] != null)                            h = nextIndex(h, len);                        table[h] = c;                        size++;                    }                }            }        }    }}