ThreadLocal 定义，以及是否可能引发的内存泄露(threadlocalMap的Key是弱引用，用线程池有可能泄露)

ThreadLocal 也能够跟踪一个请求，从接收请求，处理请求，到返回请求，只要线程不销毁，就能够在线程的任何地方，调用这个参数，这是百度二面的题目，参考：

Threadlocal 传递参数(百度二面)

总结：

1. JVM利用设置ThreadLocalMap的Key为弱引用，来避免内存泄露。
2. JVM利用调用remove、get、set方法的时候，回收弱引用。
3. 当ThreadLocal存储不少Key为null的Entry的时候，而再也不去调用remove、get、set方法，那么将致使内存泄漏。
4. 当使用static ThreadLocal的时候，延长ThreadLocal的生命周期，那也可能致使内存泄漏。由于，static变量在类未加载的时候，它就已经加载，当线程结束的时候，static变量不必定会回收。那么，比起普通成员变量使用的时候才加载，static的生命周期加长将更容易致使内存泄漏危机。http://www.importnew.com/22039.html

　

那么如何有效的避免呢？

事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也便是ThreadLocal为null）进行判断，若是为null的话，那么是会对value置为null的。咱们也能够经过调用ThreadLocal的remove方法进行释放！

threadlocal里面使用了一个存在弱引用的map,当释放掉threadlocal的强引用之后,map里面的value却没有被回收.而这块value永远不会被访问到了. 因此存在着内存泄露. 最好的作法是将调用threadlocal的remove方法.

　　在threadlocal的生命周期中,都存在这些引用. 看下图: 实线表明强引用,虚线表明弱引用.

　　

　　每一个thread中都存在一个map, map的类型是ThreadLocal.ThreadLocalMap. Map中的key为一个threadlocal实例. 这个Map的确使用了弱引用,不过弱引用只是针对key. 每一个key都弱引用指向threadlocal. 当把threadlocal实例置为null之后,没有任何强引用指向threadlocal实例,因此threadlocal将会被gc回收. 可是,咱们的value却不能回收,由于存在一条从current thread链接过来的强引用. 只有当前thread结束之后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将所有被GC回收.

　　因此得出一个结论就是只要这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间不会被回收的，就发生了咱们认为的内存泄露。其实这是一个对概念理解的不一致，也没什么好争论的。最要命的是线程对象不被回收的状况，这就发生了真正意义上的内存泄露。好比使用线程池的时候，线程结束是不会销毁的，会再次使用的。就可能出现内存泄露。　　

　　PS.Java为了最小化减小内存泄露的可能性和影响，在ThreadLocal的get,set的时候都会清除线程Map里全部key为null的value。因此最怕的状况就是，threadLocal对象设null了，开始发生“内存泄露”，而后使用线程池，这个线程结束，线程放回线程池中不销毁，这个线程一直不被使用，或者分配使用了又再也不调用get,set方法，那么这个期间就会发生真正的内存泄露。 

应用场景

最多见的ThreadLocal使用场景为 用来解决 数据库链接、Session管理等。如

private static ThreadLocal < Connection > connectionHolder = new ThreadLocal < Connection > () {
    public Connection initialValue() {
        return DriverManager.getConnection(DB_URL);
    }
};

public static Connection getConnection() {
    return connectionHolder.get();
}
private static final ThreadLocal threadSession = new ThreadLocal();

public static Session getSession() throws InfrastructureException {
    Session s = (Session) threadSession.get();
    try {
        if (s == null) {
            s = getSessionFactory().openSession();
            threadSession.set(s);
        }
    } catch (HibernateException ex) {
        throw new InfrastructureException(ex);
    }
    return s;
} 

1、目录

     一、ThreadLocal是什么？有什么用？

     二、ThreadLocal源码简要总结？

     三、ThreadLocal为何会致使内存泄漏？

2、ThreadLocal是什么？有什么用？

引入话题：在并发条件下，如何正确得到共享数据？举例：假设有多个用户须要获取用户信息，一个线程对应一个用户。在mybatis中，session用于操做数据库，那么设置、获取操做分别是session.set()、session.get()，如何保证每一个线程都能正确操做达到想要的结果？

/**
 * 回顾synchronized在多线程共享线程的问题
 * @author qiuyongAaron
 */
public class ThreadLocalOne {
     volatile Person person=new Person();
 
     public  synchronized String setAndGet(String name){
          //System.out.print(Thread.currentThread().getName()+":");
           person.name=name;
           //模拟网络延迟
           try {
                TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
                e.printStackTrace();
           }
           return person.name;
     }
 
     public static void main(String[] args) {
           ThreadLocalOne  threadLocal=new ThreadLocalOne();
           new Thread(()->System.out.println(threadLocal.setAndGet("arron")),"t1").start();
           new Thread(()->System.out.println(threadLocal.setAndGet("tony")),"t2").start();
     }
}
 
class Person{
     String name="tom";
     public Person(String name) {
           this.name=name;
     }
 
     public Person(){}
}
 
运行结果：
无synchronized：
t1:tony
t2:tony
 
有synchronized：
t1:arron
t2:tony

 

步骤分析：

1. 无synchronized的时候，由于非原子操做，显然不是预想结果，可参考我关于synchronized的讨论。
2. 如今，咱们的需求是：每一个线程独立的设置获取person信息，不被线程打扰。
3. 由于，person是共享数据，用同步互斥锁synchronized，当一个线程访问共享数据的时候，其余线程堵塞，再也不多余赘述。

 

经过举例问题，可能你们又会很疑惑？

mybatis、hibernate是如何实现的呢？

synchronized不会很消耗资源，当成千上万个操做的时候，承受并发不说，数据返回延迟如何确保用户体验？

 

ThreadLocal是什么？有什么用？

/**
 * 谈谈ThreadLocal的做用
 * @author qiuyongAaron
 */
public class ThreadLocalThree {
     ThreadLocal<Person> threadLocal=new ThreadLocal<Person>();
     public String setAndGet(String name){
           threadLocal.set(new Person(name));
           try {
                TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
                e.printStackTrace();
           }
           return threadLocal.get().name;
     }
 
     public static void main(String[] args) {
           ThreadLocalThree  threadLocal=new ThreadLocalThree();
           new Thread(()->System.out.println("t1:"+threadLocal.setAndGet("arron")),"t1").start();
           new Thread(()->System.out.println("t2:"+threadLocal.setAndGet("tony")),"t2").start();
     }
}
运行结果：
t1:arron
t2:tony

 

 

分析：

一、根据预期结果，那ThreadLocal究竟是什么？

回顾Java内存模型：

　　

      在虚拟机中，堆内存用于存储共享数据（实例对象），堆内存也就是这里说的主内存。

     每一个线程将会在堆内存中开辟一块空间叫作线程的工做内存，附带一块缓存区用于存储共享数据副本。那么，共享数据在堆内存当中，线程通讯就是经过主内存为中介，线程在本地内存读而且操做完共享变量操做完毕之后，把值写入主内存。

1. ThreadLocal被称为线程局部变量，说白了，他就是线程工做内存的一小块内存，用于存储数据。
2. 那么，ThreadLocal.set()、ThreadLocal.get()方法，就至关于把数据存储于线程本地，取也是在本地内存读取。就不会像synchronized须要频繁的修改主内存的数据，再把数据复制到工做内存，也大大提升访问效率。

 

二、ThreadLocal到底有什么用？

1. 回到最开始的举例，也就等价于mabatis、hibernate为何要使用threadlocal来存储session？
2. 做用一：由于线程间的数据交互是经过工做内存与主存的频繁读写完成通讯，然而存储于线程本地内存，提升访问效率，避免线程阻塞形成cpu吞吐率降低。
3. 做用二：在多线程中，每个线程都须要维护session，轻易完成对线程独享资源的操做。

 

总结：

     Threadlocal是什么？在堆内存中，每一个线程对应一块工做内存，threadlocal就是工做内存的一小块内存。

     Threadlocal有什么用？threadlocal用于存取线程独享数据，提升访问效率。

3、ThreadLocal源码简要总结？

那有同窗可能仍是有点云里雾里，感受仍是没有吃透？那线程内部如何去保证线程独享数据呢？

 

在这里，我只作简要总结，如有兴趣，可参考文章尾部的文章连接。重点看get、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);
 }

 

分析：

1. 一个线程对应一个ThreadLocalMap ，能够存储多个ThreadLocal对象。
2. ThreadLocal对象做为key、独享数据做为value。
3. ThreadLocalMap可参考HashMap，在ThreadMap里面存在Entry数组也就是一个Entry一个键值对。

public T get() {
        Thread t = Thread.currentThread();
        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;
            }
        }
        return setInitialValue();
    }

 

分析：

1. 一个线程对应一个ThreadLocalMap，get()就是当前线程获取本身的ThreadLocalMap。
2. 线程根据使用那一小块的threadlocal，根据ThreadLocal对象做为key，去获取存储于ThreadLocalMap中的值。

 

总结：

     回顾一下，咱们在单线程中如何使用HashMap的？hashMap根据数组+链表来实现HashMap，一个key对应一个value。那么，咱们抽象一下，Threadlocal也至关于在多线程中的一种HashMap用法，至关于对ThradLocal的操做也就如单线程操做同样。

     总之，ThreadLocal就是堆内存的一块小内存，它用ThreadLocalMap维护ThreadLocal对象做为key，独享数据做为value的东西。

 

4、ThreadLocal为何会致使内存泄漏？

synchronized是用时间换空间(牺牲时间)、ThreadLocal是用空间换时间(牺牲空间)，为何这么说？

由于synchronized操做数据，只须要在主存存一个变量便可，就阻塞等共享变量，而ThreadLocal是每一个线程都建立一块小的堆工做内存。显然，印证了上面的说法。

 

一个线程对应一块工做内存，线程能够存储多个ThreadLocal。那么假设，开启1万个线程，每一个线程建立1万个ThreadLocal，也就是每一个线程维护1万个ThreadLocal小内存空间，并且当线程执行结束之后，假设这些ThreadLocal里的Entry还不会被回收，那么将很容易致使堆内存溢出。

 

怎么办？难道JVM就没有提供什么解决方案吗？

ThreadLocal固然有想到，因此他们把ThreadLocal里的Entry设置为弱引用，当垃圾回收的时候，回收ThreadLocal。

什么是弱引用？

1. Key使用强引用：也就是上述说的状况，引用ThreadLocal的对象被回收了，ThreadLocal的引用ThreadLocalMap的Key为强引用并无被回收，若是不手动回收的话，ThreadLocal将不会回收那么将致使内存泄漏。
2. Key使用弱引用：引用的ThreadLocal的对象被回收了，ThreadLocal的引用ThreadLocalMap的Key为弱引用，若是内存回收，那么将ThreadLocalMap的Key将会被回收，ThreadLocal也将被回收。value在ThreadLocalMap调用get、set、remove的时候就会被清除。
3. 比较两种状况，咱们能够发现：因为ThreadLocalMap的生命周期跟Thread同样长，若是都没有手动删除对应key，都会致使内存泄漏，可是使用弱引用能够多一层保障：弱引用ThreadLocal不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。

 

那按你这么说，既然JVM有保障了，还有什么内存泄漏可言？

ThreadLocalMap使用ThreadLocal对象做为弱引用，当垃圾回收的时候，ThreadLocalMap中Key将会被回收，也就是将Key设置为null的Entry。 若是线程迟迟没法结束，也就是ThreadLocal对象将一直不会回收，回顾到上面存在不少线程+TheradLocal，那么也将致使内存泄漏。(内存泄露的重点)

 

其实，在ThreadLocal中，当调用remove、get、set方法的时候，会清除为null的弱引用，也就是回收ThreadLocal。

  ThreadLocal提供一个线程（Thread）局部变量，访问到某个变量的每个线程都拥有本身的局部变量。说白了，ThreadLocal就是想在多线程环境下去保证成员变量的安全。 

ThreadLocal提供的方法

 

ThreadLocal API

对于ThreadLocal而言，经常使用的方法，就是get/set/initialValue方法。

咱们先来看一个例子

 

demo

运行结果

 

是你想象中的结果么？

很显然，在这里，并无经过ThreadLocal达到线程隔离的机制，但是ThreadLocal不是保证线程安全的么？这是什么鬼？

虽然，ThreadLocal让访问某个变量的线程都拥有本身的局部变量，可是若是这个局部变量都指向同一个对象呢？这个时候ThreadLocal就失效了。仔细观察下图中的代码，你会发现，threadLocal在初始化时返回的都是同一个对象a！

 

看一看ThreadLocal源码

咱们直接看最经常使用的set操做：

 

set

 

 

线程局部变量

 

 

createMap

 

你会看到，set须要首先得到当前线程对象Thread；

而后取出当前线程对象的成员变量ThreadLocalMap；

若是ThreadLocalMap存在，那么进行KEY/VALUE设置，KEY就是ThreadLocal；

若是ThreadLocalMap没有，那么建立一个；

说白了，当前线程中存在一个Map变量，KEY是ThreadLocal，VALUE是你设置的值。

看一下get操做：

 

get

这里其实揭示了ThreadLocalMap里面的数据存储结构，从上面的代码来看，ThreadLocalMap中存放的就是Entry，Entry的KEY就是ThreadLocal，VALUE就是值。

ThreadLocalMap.Entry：

 

弱引用？

 

在JAVA里面，存在强引用、弱引用、软引用、虚引用。这里主要谈一下强引用和弱引用。

强引用，就没必要说了，相似于：

A a = new A();

B b = new B();

考虑这样的状况：

C c = new C(b);

b = null;

考虑下GC的状况。要知道b被置为null，那么是否意味着一段时间后GC工做能够回收b所分配的内存空间呢？答案是否认的，由于即使b被置为null，可是c仍然持有对b的引用，并且仍是强引用，因此GC不会回收b原先所分配的空间！既不能回收利用，又不能使用，这就形成了内存泄露。

那么如何处理呢？

能够c = null;也可使用弱引用！（WeakReference w = new WeakReference(b);）

分析到这里，咱们能够获得：

 

内存结构图

这里咱们思考一个问题：ThreadLocal使用到了弱引用，是否意味着不会存在内存泄露呢？ 

首先来讲，若是把ThreadLocal置为null，那么意味着Heap中的ThreadLocal实例不在有强引用指向，只有弱引用存在，所以GC是能够回收这部分空间的，也就是key是能够回收的。可是value却存在一条从Current Thread过来的强引用链。所以只有当Current Thread销毁时，value才能获得释放。

所以，只要这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间内不会被回收的，就发生了咱们认为的内存泄露。最要命的是线程对象不被回收的状况，好比使用线程池的时候，线程结束是不会销毁的，再次使用的，就可能出现内存泄露。

那么如何有效的避免呢？

事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也便是ThreadLocal为null）进行判断，若是为null的话，那么是会对value置为null的。咱们也能够经过调用ThreadLocal的remove方法进行释放！

 

 

 

参考：ThreadLocal可能引发的内存泄露

参考：对ThreadLocal实现原理的一点思考

参考：并发编程（四）：ThreadLocal从源码分析总结到内存泄漏