java并发编程——史上最全最详细的ThreadLocal

什么是ThreadLocal？

1、线程并发：在多线程场景下
2、传递数据：我们可以通过ThreadLocal在同一线程，不同组件中传递变量
3：线程隔离：每个线程的变量都是独立的，不会互相影响

ThreadLocal的使用场景

先看一段代码：

public class ThreadLocalTest {
    private  String content ;
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public static void main(String[] args) {
        ThreadLocalTest threadLocalTest = new ThreadLocalTest();

        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    threadLocalTest.setContent(Thread.currentThread().getName()+"的数据");
                    System.out.println("--------------------------");
                    System.out.println(Thread.currentThread().getName()+"------------>"+threadLocalTest.getContent());
                }
            });
            thread.setName("线程"+i);
            thread.start();
        }
    }
}

输出入下：

当多个线程访问变量时，每个线程中的变量都不是相互独立的。由上图可知，线程1访问到线程4的数据，等等。很明显线程未隔离。使用ThreadLocal后，代码如下：

public class ThreadLocalTest {
    ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public String getContent() {
        return threadLocal.get();
    }
    public void setContent(String content) {
            threadLocal.set(content);
    }

    public static void main(String[] args) {
        ThreadLocalTest threadLocalTest = new ThreadLocalTest();

        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    threadLocalTest.setContent(Thread.currentThread().getName()+"的数据");
                    System.out.println("--------------------------");
                    System.out.println(Thread.currentThread().getName()+"------------>"+threadLocalTest.getContent());
                }
            });
            thread.setName("线程"+i);
            thread.start();
        }
    }
}

运行结果如下：

由结果可知，线程i只访问线程i的数据，实现了线程隔离。由上可知，Threadlocal只是实现了线程间变量的隔离，线程0-4仍然是并发执行。

ThreadLocal与synchronized的区别

	synchronized	ThreadLocal
原理	同步机制采用‘以时间换空间’的方式，只提供一份变量，让不同的线程排队访问	ThreadLocal采用‘以空间换时间’的方式，为每一个线程都提供一份变量的副本，从而时间同时访问而互相不干扰
侧重点	多个线程之间访问资源的同步	多线程让每个线程之间的数据相互隔离

总结:在刚刚的案例中，虽然使用ThreadLocal和synchronized都能解决问题，但是使用ThradLocal更为合适，因为这样可以使程序拥有更高的并发性。

ThreadLocal如何实现线程安全？

ThreadLocal早期设计为每一个ThreadLocal都创建一个Map，然后线程作为Map的key,要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果
在JDK 1.8之后，ThreadLocal的设计是：每个thread维护一个ThreadLocalMap,这个Map的key是ThreadLocal实例本身，value才是真正要储存的值Object。具体的过程如下：

（1）每个Thread线程内部都有一个Map（ThreadLocalMap）

（2）Map里面存储ThreadLoca对象（key）和线程的变量副本（value）

（3）Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。

（4）对于不同的线程每次获取副本值时，别的线程并不能获取当前线程的副本值，形成了副本的隔离，互不干扰。

如下图所示：

ThreadLocal常用方法

get()方法

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);    //t为当前线程
        if (map != null) {
        //this为当前的ThreadLocal对象，也就是ThreadLocalMap 中的key
            ThreadLocalMap.Entry e = map.getEntry(this);	
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
    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);
        return value;
    }

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

remove()方法

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

ThreadLocal内存泄漏问题

内存泄漏与内存溢出

Memory overflow：内存溢出，没有足够的内存提供申请者使用
Memory leak:内存泄漏是指程序中已动态分配的内存空间由于某种原因未释放或无法释放，造成系统内存浪费，导致程序变慢甚至崩溃等严重后果。内存泄漏堆积最终导致内存溢出。

引用的类型

强引用：如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

软引用：如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

弱引用：弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

虚引用：“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

ThreadLocal内存泄漏的原因

ThreadLocal调用时，内存关系如上图所示。
如上图，当ThreadLocal使用完时，ThreadLocal的引用ThreadLocal Ref被回收，ThreadLocalMap中的key持有ThreadLocal的弱引用，所以ThreadLocal就可以顺利被gc回收，回收之后，ThreadLocalMap中的key为null。如果没有手动删除（调用remove方法）这个Entry，以及CurrentThread依然运行的情况下，存在强引用链threadRef->currentThread Ref->threadLocalMap->entry->value，所以value不会被回收，而这块value不会被访问到了，导致value内存泄漏。

导致内存泄漏的原因与是否为强弱引用无关，就算是强引用，也会存在内存泄漏

为什么ThreadLocal要使用弱引用？

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

为什么要使用弱引用而不使用强引用呢？因为在ThreadLocalMap中的set/getEntry方法中，会对key为null进行判断，如果为null的话，会将value置为null;这就意味着，CurrentThread运行情况下，就算忘记使用remove方法，弱引用比强引用多一层保障，弱引用的ThreadLocal会被回收，对应的value在下次ThreadLocalMap调用set，get，remove任何一个方法时会被清除，从而避免内存泄漏。

注意：这里并不是单单弱引用避免了内存泄漏，无论使用弱引用还是强引用都会产生内存泄漏。避免内存泄漏的条件，以下缺一不可：
（1）对key为null进行判断，如果为null的话，会将value置为null
（2）再加上弱引用
（3）再次调用get,set，remove方法
以上3个条件中，条件（3）有可能不会发生，所以不能保证内存完全不泄露。

如何避免ThreadLocal内存泄漏

1、使用完ThreadLocal，调用其remove方法删除对应的Entry

2、使用完ThreadLocal，当前Thread也随之结束。

相对于第二种方式，第一种方式更好实现。只要记得在使用完ThreadLocal及时的调用remove，无论key是强引用还是弱引用，都不会有问题。