1.4 ThreadLocalRandom 可将其实例设置到静态变量，在多线程下重用吗？

current()的时候初始化一个初始化种子到线程，每次nextseed再使用之前的种子生成新的种子：

UNSAFE.putLong(t = Thread.currentThread(), SEED,
r = UNSAFE.getLong(t, SEED) + GAMMA);

如果你通过主线程调用一次current生成一个ThreadLocalRandom实例保存，那么其它线程来获取种子的时候必然取不到初始种子，必须是每一个线程自己用的时候初始化一个种子到线程。

可以在nextSeed设置一个断点看看：

UNSAFE.getLong(Thread.currentThread(),SEED);

2 内存泄漏

在源码注释中提示使用static关键字来修饰ThreadLocal.

在此场景下,寄希望于ThreadLocal对象失去引用后,触发弱引用机制来回收Entry的Value就不现实了.

在上例中,如果不进行remove(),那么当该线程执行完成后,通过ThreadLocal对象持有的String对象是不会被释放的.

以上两个问题的解决办法很简单
每次用完ThreadLocal时,及时调用remove()清理

What is ThreadLocal

该类提供了线程局部 (thread-local) 变量;

这些变量不同于它们的普通对应物,因为访问某变量（通过其 get /set 方法）的每个线程都有自己的局部变量,它独立于变量的初始化副本.

ThreadLocal 实例通常是类中的 private static字段,希望将状态与某一个线程（e.g. 用户 ID 或事务 ID）相关联.

一个以ThreadLocal对象为键、任意对象为值的存储结构;

有点像HashMap,可以保存"key : value"键值对,但一个ThreadLocal只能保存一个键值对,各个线程的数据互不干扰.

该结构被附带在线程上,也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值.

ThreadLocal<String> localName = new ThreadLocal();
localName.set("JavaEdge");
String name = localName.get();

在线程A中初始化了一个ThreadLocal对象localName，并set了一个值JavaEdge;

同时在线程A中通过get可拿到之前设置的值;

但是如果在线程B中,拿到的将是一个null.

因为ThreadLocal保证了各个线程的数据互不干扰

看看set(T value)和get()方法的源码

可见,每个线程中都有一个ThreadLocalMap

执行set时,其值是保存在当前线程的threadLocals变量
执行get时,从当前线程的threadLocals变量获取

所以在线程A中set的值,是线程B永远得不到的

即使在线程B中重新set,也不会影响A中的值;

保证了线程之间不会相互干扰.

追寻本质 - 结构

从名字上看猜它类似HashMap,但在ThreadLocal中,并无实现Map接口

在ThreadLoalMap中,也是初始化一个大小为16的Entry数组
Entry节点对象用来保存每一个key-value键值对
这里的key 恒为 ThreadLocal;

通过ThreadLocal的set(),把ThreadLocal对象自身当做key,放进ThreadLoalMap

ThreadLoalMap的Entry继承WeakReference
和HashMap很不同,Entry中没有next字段,所以不存在链表情形.

hash冲突

无链表,那发生hash冲突时何解？

先看看ThreadLoalMap插入一个 key/value 的实现

每个ThreadLocal对象都有一个hash值 - threadLocalHashCode

每初始化一个ThreadLocal对象,hash值就增加一个固定大小

在插入过程中,根据ThreadLocal对象的hash值,定位至table中的位置i.

过程如下

若当前位置为空,就初始化一个Entry对象置于i;
位置i已有对象
若该Entry对象的key正是将设置的key,覆盖其value(和HashMap 处理相同);

若和即将设置的key 无关,则寻找下一个空位

如此,在get时,也会根据ThreadLocal对象的hash值,定位到table中的位置.然后判断该位置Entry对象中的key是否和get的key一致,如果不一致,就判断下一个位置.

可见,set和get如果冲突严重的话,效率很低,因为ThreadLoalMap是Thread的一个属性，所以即使在自己的代码中控制了设置的元素个数，但还是不能控制其它代码的行为

内存泄露

ThreadLocal可能导致内存泄漏，为什么？

先看看Entry的实现：

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

通过之前的分析已经知道，当使用ThreadLocal保存一个value时，会在ThreadLocalMap中的数组插入一个Entry对象，按理说key-value都应该以强引用保存在Entry对象中，但在ThreadLocalMap的实现中，key被保存到了WeakReference对象中

这就导致了一个问题，ThreadLocal在没有外部强引用时，发生GC时会被回收，如果创建ThreadLocal的线程一直持续运行，那么这个Entry对象中的value就有可能一直得不到回收，发生内存泄露。

避免内存泄露

既然发现有内存泄露的隐患，自然有应对策略，在调用ThreadLocal的get()、set()可能会清除

ThreadLocalMap中key为null的Entry对象，这样对应的value就没有GC Roots可达了，下次GC的时候就可以被回收，当然如果调用remove方法，肯定会删除对应的Entry对象。

如果使用ThreadLocal的set方法之后，没有显示的调用remove方法，就有可能发生内存泄露，所以养成良好的编程习惯十分重要，使用完ThreadLocal之后，记得调用remove方法。

ThreadLocal<String> localName = new ThreadLocal();
try {
    localName.set("JavaEdge");
    // 其它业务逻辑
} finally {
    localName.remove();
}

题外小话

首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的.

一般情况下，通过set() 到线程中的对象是该线程自己使用的对象,其他线程是不需要访问的,也访问不到的;

各个线程中访问的是不同的对象.

另外，说ThreadLocal使得各线程能够保持各自独立的一个对象;

并不是通过set()实现的,而是通过每个线程中的new 对象的操作来创建的对象,每个线程创建一个，不是什么对象的拷贝或副本。

通过set()将这个新创建的对象的引用保存到各线程的自己的一个map中,每个线程都有这样一个map;

执行get()时,各线程从自己的map中取出放进去的对象,因此取出来的是各自线程中的对象.

ThreadLocal实例是作为map的key来使用的.

如果set()进去的东西本来就是多个线程共享的同一个对象;

那么多个线程的get()取得的还是这个共享对象本身，还是有并发访问问题。

Hibernate中典型的 ThreadLocal 应用

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

首先判断当前线程中有没有放入 session,如果还没有,那么通过sessionFactory().openSession()来创建一个session;

再将session set()到线程中,实际是放到当前线程的ThreadLocalMap;

这时,对于该 session 的唯一引用就是当前线程中的那个ThreadLocalMap;

threadSession 作为这个值的key，要取得这个 session 可以通过threadSession.get();

里面执行的操作实际是先取得当前线程中的ThreadLocalMap;

然后将threadSession作为key将对应的值取出.

这个 session 相当于线程的私有变量,而不是public的.

显然，其他线程中是取不到这个session的，他们也只能取到自己的ThreadLocalMap中的东西。要是session是多个线程共享使用的，那还不乱套了.

如果不用ThreadLocal怎么实现呢？

可能就要在action中创建session，然后把session一个个传到service和dao中，这可够麻烦的;

或者可以自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中，应该也行，这也是一般人的想法.

但事实上，ThreadLocal的实现刚好相反，它是在每个线程中有一个map，而将ThreadLocal实例作为key，这样每个map中的项数很少，而且当线程销毁时相应的东西也一起销毁了

总之，ThreadLocal不是用来解决对象共享访问问题的;

而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式

每个线程中都有一个自己的ThreadLocalMap类对象;

可以将线程自己的对象保持到其中,各管各的,线程可以正确的访问到自己的对象.

将一个共用的ThreadLocal静态实例作为key,将不同对象的引用保存到不同线程的ThreadLocalMap中,然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象,避免了将这个对象作为参数传递的麻烦.

当然如果要把本来线程共享的对象通过set()放到线程中也可以，可以实现避免参数传递的访问方式;

但是要注意get()到的是那同一个共享对象，并发访问问题要靠其他手段来解决;

但一般来说线程共享的对象通过设置为某类的静态变量就可以实现方便的访问了，似乎没必要放到线程中

ThreadLocal的应用场合

我觉得最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

可以看到ThreadLocal类中的变量只有这3个int型：

private final int threadLocalHashCode = nextHashCode();  
private static AtomicInteger nextHashCode =
        new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;

而作为ThreadLocal实例的变量只有 threadLocalHashCode

nextHashCode 和HASH_INCREMENT 是ThreadLocal类的静态变量

实际上

HASH_INCREMENT是一个常量，表示了连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量

nextHashCode 表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode 的值

看一下创建一个ThreadLocal实例即new ThreadLocal()时做了哪些操作，构造方法ThreadLocal()里什么操作都没有，唯一的操作是这句

private final int threadLocalHashCode = nextHashCode();

那么nextHashCode()做了什么呢

private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

就是将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的threadLocalHashCode，然后nextHashCode的值增加HASH_INCREMENT这个值。.

因此ThreadLocal实例的变量只有这个threadLocalHashCode，而且是final的，用来区分不同的ThreadLocal实例;

ThreadLocal类主要是作为工具类来使用，那么set()进去的对象是放在哪儿的呢？

看一下上面的set()方法，两句合并一下成为

ThreadLocalMap map = Thread.currentThread().threadLocals;

这个ThreadLocalMap 类是ThreadLocal中定义的内部类，但是它的实例却用在Thread类中：

public class Thread implements Runnable {  
    ......  
    /* ThreadLocal values pertaining to this thread. This map is maintained 
     * by the ThreadLocal class. */  
    ThreadLocal.ThreadLocalMap threadLocals = null;    
    ......  
}

再看这句：

if (map != null)  
    map.set(this, value);

也就是将该ThreadLocal实例作为key，要保持的对象作为值，设置到当前线程的ThreadLocalMap 中，get()方法同样看了代码也就明白了.

阿里三面:说说线程封闭与ThreadLocal的关系（下）