探索JAVA并发 - ThreadLocal

最新推荐文章于 2024-04-13 13:55:29 发布

acupt

最新推荐文章于 2024-04-13 13:55:29 发布

阅读量131

点赞数

本文链接：https://blog.csdn.net/u014769764/article/details/100517493

版权

使用ThreadLocal可以维持线程封闭性，使线程中的某个值与保存值的对象关联，防止对可变的单例变量或全局变量进行共享，但使用不当也会造成内存泄漏，先了解它，再使用它。

从SimpleDateFormat说起

SimpleDateFormat是我们常用的日期格式化工具，但熟悉的朋友都知道它是线程不安全的。

SimpleDateFormat用法

public class Acuptest {	
    public static void main(String[] args) {	
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS");	
        System.out.println(sdf.format(new Date()));	
    }	
}

SimpleDateFormat线程不安全场景

上面的用法完全没有问题，但现在spring无处不在，很多类都是以bean的形式存在于spring容器被各种共享，一不小心就会写成下面这种样子。

public class Acuptest {	
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS");	
    public String format(Date date) {	
        return sdf.format(date);	
    }	
}

只是这样还看不出什么问题，但既然提到了SimpleDateFormat是线程不安全的，那么就看看为什么不安全。

SimpleDateFormat线程不安全分析

进入源码，只看关键部分。

public abstract class DateFormat extends Format {	
    // 一个成员变量	
    protected Calendar calendar;	
    // 一个抽象方法	
    public abstract StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition);	
    // 提供给外部使用的方法	
    public final String format(Date date){	
        return format(date, new StringBuffer(),	
                      DontCareFieldPosition.INSTANCE).toString();	
    }	
}	
public class SimpleDateFormat extends DateFormat {	
    // 实现了父类的抽象方法	
    @Override	
    public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition pos){	
        pos.beginIndex = pos.endIndex = 0;	
        return format(date, toAppendTo, pos.getFieldDelegate());	
    }	
    private StringBuffer format(Date date, StringBuffer toAppendTo, FieldDelegate delegate) {	
        // 到这里就能发现问题了，竟然给成员变量设置成了传进来的参数	
        // 在并发情况下calendar的值就不可信了，可能线程A前脚刚设置完准备执行下一条语句，线程B紧随其后就把值给改了	
        // Convert input date to time field list	
        calendar.setTime(date);	
        boolean useDateFormatSymbols = useDateFormatSymbols();	
        // 略	
    }	
}

SimpleDateFormat线程安全用法

使用局部变量

只要不让多线程访问同一个对象，每次要用就new一个对象即可。

使用ThreadLocal

很多时候某些对象往往不适合频繁创建、销毁，但它又像SimpleDateFormat那样线程不安全。这时候ThreadLocal就有用武之地了。

public class Acuptest {	
    // 为每个线程单独分配一个SimpleDateFormat，线程内部可以复用，线程之间不能共享。	
    private ThreadLocal&lt;SimpleDateFormat&gt; sdf = new ThreadLocal&lt;SimpleDateFormat&gt;() {	
        @Override	
        protected SimpleDateFormat initialValue() {	
            // get()方法获取不到当前线程的SimpleDateFormat对象时，会调用此方法创建一个并绑定到线程	
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS");	
        }	
    };	
    public String format(Date date) {	
        return sdf.get().format(date);	
    }

ThreadLocal源码分析

public class ThreadLocal&lt;T&gt; {	
    //...	
    // 获取当前线程绑定的对象，如果没有，将调用initialValue生成一个并绑定	
    public T get() {	
        // 获取当前线程	
        Thread t = Thread.currentThread();	
        // 从当前线程中取到一个MAP	
        // key: ThreadLocal	
        // value: ThreadLocal的泛型 &lt;T&gt;	
        ThreadLocalMap map = getMap(t);	
        if (map != null) {	
            ThreadLocalMap.Entry e = map.getEntry(this);	
            if (e != null) {	
                @SuppressWarnings("unchecked")	
                T result = (T)e.value;	
                return result;	
            }	
        }	
        // Thread对象可能还没创建ThreadLocalMap成员变量	
        // 或者ThreadLocalMap里没有当前ThreadLocal对象对应的&lt;T&gt;值	
        // 此时需要设置初始值	
        return setInitialValue();	
    }	
    // 获取线程里的MAP	
    ThreadLocalMap getMap(Thread t) {	
        return t.threadLocals;	
    }	
    // 设置初始值	
    private T setInitialValue() {	
        // 创建一个新的对象	
        T value = initialValue();	
        // 重新获取当前线程，因为没有参数接收线程信息	
        Thread t = Thread.currentThread();	
        ThreadLocalMap map = getMap(t);	
        if (map != null)	
            map.set(this, value); // 设置初始值	
        else	
            createMap(t, value); // 创建MAP并设置初始值	
        return value;	
    }	
    // 初始化一个对象，默认返回null，可在使用时重写此方法	
    protected T initialValue() {	
        return null;	
    }	
    // ...	
}

Thread源码分析

上面的源码中看到ThreadLocal多次使用Thread中的成员变量threadLocals，于是对Thread对象的结构再做个简单了解。

public class Thread implements Runnable {	
    /* ThreadLocal values pertaining to this thread. This map is maintained	
     * by the ThreadLocal class. */	
    ThreadLocal.ThreadLocalMap threadLocals = null;	
    /*	
     * InheritableThreadLocal values pertaining to this thread. This map is	
     * maintained by the InheritableThreadLocal class.	
     */	
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;	
    // 略	
}	
public class ThreadLocal&lt;T&gt; {	
    static class ThreadLocalMap {	
        static class Entry extends WeakReference&lt;ThreadLocal&lt;?&gt;&gt; {	
            /** The value associated with this ThreadLocal. */	
            Object value;	
            Entry(ThreadLocal&lt;?&gt; k, Object v) {	
                super(k);	
                value = v;	
            }	
        }	
        /**	
         * The table, resized as necessary.	
         * table.length MUST always be a power of two.	
         */	
        private Entry[] table;	
    }	
}

threadLocals和inheritableThreadLocals

从Thread源码中可以看到ThreadLocal.ThreadLocalMa类型的成员变量有两个，有个是之前没有见过的inheritableThreadLocals，这个变量不是给ThreadLocal用的，而是给另一个类似的工具InheritableThreadLocal用的。

public class InheritableThreadLocal&lt;T&gt; extends ThreadLocal&lt;T&gt; {	
    protected T childValue(T parentValue) {	
        return parentValue;	
    }	
    ThreadLocalMap getMap(Thread t) {	
       return t.inheritableThreadLocals;	
    }	
    void createMap(Thread t, T firstValue) {	
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);	
    }	
}

从源码上看，InheritableThreadLocal继承了ThreadLocal，然后使用的MAP换了，其他就没什么特别的。

但InheritableThreadLocal有着特殊的功能：它可以使用父线程的inheritableThreadLocals变量，实现父子线程共享变量。

InheritableThreadLocal为什么可以让子线程使用父线程的变量，关键的地方不在它，而在Thread类的初始化流程，Thread初始化时，

public class Thread implements Runnable {	
    private void init(ThreadGroup g, Runnable target, String name,	
                      long stackSize, AccessControlContext acc,	
                      boolean inheritThreadLocals) {	
        // 略	
        Thread parent = currentThread();	
        // 略	
        // inheritThreadLocals默认为true	
        // 父线程inheritableThreadLocals不为空则复制一份	
        // 值复制，非引用复制	
        // 只是复制父线程当前拥有的对象	
        if (inheritThreadLocals &amp;&amp; parent.inheritableThreadLocals != null)	
            this.inheritableThreadLocals =	
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);	
        // 略	
    }	
}

ThreadLocal中的弱引用(WeakReference)

从上面的源码中注意到: ThreadLocal.ThreadLocalMap.Entry extends WeakReference<threadlocal</threadlocal

Entry的key是ThreadLocal，是个弱引用（被GC扫描到就回收）。如果不这样，当ThreadLocal用完了，但线程还没结束，因此Thread里面还持有着ThreadLocal的强引用，那么它永远不会被回收，可以认为内存泄漏了。

ThreadLocal的内存泄漏

就算是使用了弱引用，依然存在内存泄漏的可能。因为弱引用仅仅是Entry的key(ThreadLocal)，value（泛型T）并不是弱引用。最终可能出现的结果就是，ThreadLocal被回收了，Thread里的MAP中KEY就没了，但value还在，这样一来这个value永远不会被get()方法返回，确又存在于内存不愿消散。

内部实现尽量避免内存泄漏：