ThreadLocal

相关链接

一、介绍

/**
 * This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * {@code get} or {@code set} method) has its own, independently initialized
 * copy of the variable.  {@code ThreadLocal} instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).
 *
 * <p>For example, the class below generates unique identifiers local to each
 * thread.
 * A thread's id is assigned the first time it invokes {@code ThreadId.get()}
 * and remains unchanged on subsequent calls.
 * <pre>
 *

import java.util.concurrent.atomic.AtomicInteger;

 public class ThreadId {
     // Atomic integer containing the next thread ID to be assigned
     private static final AtomicInteger nextId = new AtomicInteger(0);

     // Thread local variable containing each thread's ID
     private static final ThreadLocal<Integer> threadId =
         new ThreadLocal<Integer>() {
             @Override protected Integer initialValue() {
                 return nextId.getAndIncrement();
         }
     };

     // Returns the current thread's unique ID, assigning it if necessary
     public static int get() {
         return threadId.get();
     }
 }

* </pre> * <p>Each thread holds an implicit reference to its copy of a thread-local * variable as long as the thread is alive and the {@code ThreadLocal} * instance is accessible; after a thread goes away, all of its copies of * thread-local instances are subject to garbage collection (unless other * references to these copies exist). * * @author Josh Bloch and Doug Lea * @since 1.2 */
　　ThreadLocal类用来提供线程内部的局部变量，这种变量在多线程环境下访问（通过set和get方法访问）时能
保证各个线程的变量相对独立与其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用
于关联线程和线程上下文。
　　作用：提供线程内的局部变量，不同线程之间不会互相干扰，这种变量在线程的生命周期内起作用，减少同一个
线程内多个函数或组件之间一些公共变量传递的复杂度（同一线程，不同组件中传递公共变量）。

---

 二、基本使用

2.1 常用方法

2.2 使用案例

public class Demo1 {
    //变量
    private String content;

    public void setContent(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

}

public class Main {
    public static void main(String[] args) {
        final Demo1 demo = new Demo1();
//        final Demo2 demo = new Demo2();
        for(int i=0;i<5;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    //每个线程存入一个变量过一会取出
                    demo.setContent(Thread.currentThread().getName()+"的数据");
                    System.out.println("--------------------------");
                    System.out.println(Thread.currentThread().getName()+"--->"+demo.getContent());

                }
            },"线程"+i);
            thread.start();
        }
    }
}

输出：

--------------------------
--------------------------
线程3--->线程4的数据
--------------------------
线程2--->线程4的数据
--------------------------
线程1--->线程4的数据
--------------------------
线程0--->线程3的数据
线程4--->线程4的数据

修改Demo1，引入ThreadLocal

public class Demo2 {
    //变量
    private String content;
    ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public void setContent(String content) {
        threadLocal.set(content);
    }

    public String getContent() {
        return threadLocal.get();
    }

}

 输出：一一对应

--------------------------
--------------------------
线程2--->线程2的数据
--------------------------
--------------------------
线程4--->线程4的数据
--------------------------
线程3--->线程3的数据
线程0--->线程0的数据
线程1--->线程1的数据

---

 三、ThreadLocal & synchronized

3.1 使用synchronized修饰

public class Main {
    public static void main(String[] args) {
        final Demo1 demo = new Demo1();
//        final Demo2 demo = new Demo2();
        for(int i=0;i<5;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    //每个线程存入一个变量过一会取出
                    synchronized (Demo1.class){
                        demo.setContent(Thread.currentThread().getName()+"的数据");
                        System.out.println("--------------------------");
                        System.out.println(Thread.currentThread().getName()+"--->"+demo.getContent());
                    }
                }
            },"线程"+i);
            thread.start();
        }
    }
}

输出：效果相同，虽然实现了线程数据隔离的问题，但是失去了并发性。

--------------------------
线程0--->线程0的数据
--------------------------
线程4--->线程4的数据
--------------------------
线程3--->线程3的数据
--------------------------
线程2--->线程2的数据
--------------------------
线程1--->线程1的数据

3.2 区别

　　synchronized：同步机制采用以时间换空间的方式，只提供了一份变量，让不同的线程排队访问。侧重多个线程之间访问资源的同步。

　　ThreadLocal：采用以空间换时间的方式，为每一个线程提供了一份变量的副本，从而实现同时访问而互不干扰。侧重于多个线程之间的数据隔离。

---

 四、运用场景

4.1 转账

　　转入转出操作应该为原子性操作，如果之间出现异常，导致转账数据错误，例如Service代码中的ArithmeticException异常导致Jack减少100，而Rose没有增加。

package com.juc.transfer_accounts;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
 * @author Millet
 * @date 2020/4/30 23:17
 */
public class JdbcUtils {
    //通过标识名来创建相应连接池
    static ComboPooledDataSource dataSource=new ComboPooledDataSource();
    //从连接池中取用一个连接
    public static Connection getConnection() throws SQLException {
            return dataSource.getConnection();
    }
    //释放连接回连接池
    public static void release(AutoCloseable... ios){
        for(AutoCloseable io : ios){
            if(io!=null){
                try {
                    io.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void commitAndClose(Connection conn){
        if(conn!=null){
            try {
                conn.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void rollbackAndClose(Connection conn){
        if(conn != null){
            try {
                conn.rollback();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
}

package com.juc.transfer_accounts;

import java.sql.SQLException;

/**
 * @author Millet
 * @date 2020/4/30 23:17
 */
public class AccountService {
    public boolean transfer(String outUser, String inUser, int money){
        AccountDao ad = new AccountDao();
        try {
            ad.out(outUser,money);
            //转入转出应该为原子操作，如果两个操作中间出现异常，导致转账数据错误，如下所示
            int i = 1/0;
            ad.in(inUser,money);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
}

package com.juc.transfer_accounts;

/**
 * @author Millet
 * @date 2020/4/30 23:17
 */
public class AccountController {
    public static void main(String[] args) {
        //Jack给Rose转账100
        String outUser = "Jack";
        String inUser = "Rose";
        AccountService as = new AccountService();
        boolean res = as.transfer(outUser, inUser, 100);
       if(res){
           System.out.println("转账成功！");
       }else {
           System.out.println("转账失败！");
       }
    }
}

4.2 解决方案

4.2.1 事务

使用事务时需要注意：
      1.service层和Dao层的连接对象Connection需要保持一致
      2.每个线程的Connection对象必须前后一致，线程隔离
常见解决方案：
      1.传参：将service层的connection对象直接传递到Dao层（就是在Dao层方法上增加一个连接对象参数，此处应
注意Dao层不能释放连接）
      2.加锁

package com.juc.transfer_accounts;

import org.springframework.stereotype.Repository;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @author Millet
 * @date 2020/4/30 23:16
 */
public class AccountDao {
    /**
     * 传参：将service层的connection对象直接传递到Dao层（就是在Dao层方法上增加一个连接对象参数，此处应
     * 注意Dao层不能释放连接）
     */
    //转出
    public void out(String outUser, int money,Connection conn) throws SQLException {
        String sql = "update account set money = money - ? where name = ?";
//        Connection conn = JdbcUtils.getConnection();
        PreparedStatement pstm = conn.prepareStatement(sql);
        pstm.setInt(1,money);
        pstm.setString(2,outUser);
//        JdbcUtils.release(pstm,conn);
    }
    //传入
    public void in(String inUser, int money, Connection conn) throws SQLException {
        String sql = "update account set money = money + ? where name = ?";
//        Connection conn = JdbcUtils.getConnection();
        PreparedStatement pstm = conn.prepareStatement(sql);
        pstm.setInt(1,money);
        pstm.setString(2,inUser);
//        JdbcUtils.release(pstm,conn);
    }
}

 

package com.juc.transfer_accounts;

import java.sql.Connection;
/**
 * @author Millet
 * @date 2020/4/30 23:17
 */
public class AccountService {
    public boolean transfer(String outUser, String inUser, int money){
        AccountDao ad = new AccountDao();
        Connection conn = null;
        /**
         * 事务的使用注意点：
         *      1.service层和Dao层的连接对象Connection需要保持一致
         *      2.每个线程的Connection对象必须前后一致，线程隔离
         *  常见解决方案：
         *      1.传参：将service层的connection对象直接传递到Dao层
         *      2.加锁
         * 　常规解决方案弊端：
         * 　　　1.提高代码耦合度  Service-->Dao
         * 　　　2. 降低程序性能  synchronized
         */
        try {
            synchronized (AccountService.class){
                //1.开启事务
                conn = JdbcUtils.getConnection();
                conn.setAutoCommit(false);//关闭自动提交事务

                ad.out(outUser,money,conn);
                //转入转出应该为原子操作，如果两个操作中间出现异常，导致转账数据错误，如下所示
                int i = 1/0;
                ad.in(inUser,money,conn);

                JdbcUtils.commitAndClose(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();

            JdbcUtils.rollbackAndClose(conn);
            return false;
        }
        return true;
    }
}

　　常规解决方案弊端：

　　　1.提高代码耦合度Service-->Dao

　　　2. 降低程序性能 synchronized

4.2.2 ThreadLocal

　　Connection创建绑定线程，且提交事务需要解绑，防止内存泄漏。

package com.juc.transfer_accounts;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
 * @author Millet
 * @date 2020/4/30 23:17
 */
public class JdbcUtils {
    //通过标识名来创建相应连接池
    static ComboPooledDataSource dataSource=new ComboPooledDataSource();

    //从连接池中取用一个连接
    /**
     * 原本：直接从连接池中获取链接
     * 现在：
     *      1.直接获取当前线程绑定的连接对象
     *      2.如果连接对象为空
     *          2.1 再去连接池中获取链接
     *          2.2 将此链接对象跟当前线程进行绑定
     * @return
     * @throws SQLException
     */
    static ThreadLocal<Connection> tl = new ThreadLocal<>();
    public static Connection getConnection() throws SQLException {
        Connection conn = tl.get();
        if(conn == null){
            conn = dataSource.getConnection();
            tl.set(conn);
        }
        return conn;
//            return dataSource.getConnection();
    }
    //释放连接回连接池
    public static void release(AutoCloseable... ios){
        for(AutoCloseable io : ios){
            if(io!=null){
                try {
                    io.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void commitAndClose(Connection conn){
        if(conn!=null){
            try {
                conn.commit();
                //解绑当前线程绑定的连接对象
                tl.remove();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void rollbackAndClose(Connection conn){
        if(conn != null){
            try {
                conn.rollback();
                conn.close();
                //解绑当前线程绑定的连接对象
                tl.remove();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

 　　Service、Dao直接使用JdbcUtils创建conn，且不使用synchronized和传参

package com.juc.transfer_accounts;

import org.springframework.stereotype.Repository;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @author Millet
 * @date 2020/4/30 23:16
 */
public class AccountDao {
    /**
     * 传参：将service层的connection对象直接传递到Dao层（就是在Dao层方法上增加一个连接对象参数，此处应
     * 注意Dao层不能释放连接）
     */
    //转出
    public void out(String outUser, int money) throws SQLException {
        String sql = "update account set money = money - ? where name = ?";
        Connection conn = JdbcUtils.getConnection();
        PreparedStatement pstm = conn.prepareStatement(sql);
        pstm.setInt(1,money);
        pstm.setString(2,outUser);
        JdbcUtils.release(pstm,conn);
    }
    //传入
    public void in(String inUser, int money) throws SQLException {
        String sql = "update account set money = money + ? where name = ?";
        Connection conn = JdbcUtils.getConnection();
        PreparedStatement pstm = conn.prepareStatement(sql);
        pstm.setInt(1,money);
        pstm.setString(2,inUser);
        JdbcUtils.release(pstm,conn);
    }
}

package com.juc.transfer_accounts;

import java.sql.Connection;
/**
 * @author Millet
 * @date 2020/4/30 23:17
 */
public class AccountService {
    public boolean transfer(String outUser, String inUser, int money){
        AccountDao ad = new AccountDao();
        Connection conn = null;
        /**
         * 事务的使用注意点：
         *      1.service层和Dao层的连接对象Connection需要保持一致
         *      2.每个线程的Connection对象必须前后一致，线程隔离
         *  常见解决方案：
         *      1.传参：将service层的connection对象直接传递到Dao层
         *      2.加锁
         * 　常规解决方案弊端：
         * 　　　1.提高代码耦合度  Service-->Dao
         * 　　　2. 降低程序性能  synchronized
         */
        try {
//            synchronized (AccountService.class){
                //1.开启事务
                conn = JdbcUtils.getConnection();
                conn.setAutoCommit(false);//关闭自动提交事务

                ad.out(outUser,money);
                //转入转出应该为原子操作，如果两个操作中间出现异常，导致转账数据错误，如下所示
                int i = 1/0;
                ad.in(inUser,money);

                JdbcUtils.commitAndClose(conn);
//            }
        } catch (Exception e) {
            e.printStackTrace();

            JdbcUtils.rollbackAndClose(conn);
            return false;
        }
        return true;
    }
}

 　　ThreadLocal好处：

　　　　1. 传递数据：保存每个线程绑定的数据，在需要的地方可以直接获取。

　　　　2. 线程隔离：各线程之间的数据相互隔离却又具备并发性，避免同步方式带来的性能损失。

---

 五、ThreadLocal内部结构

5.1 JDK8设计

　　每个Thread维护了一个ThreadLocalMap，这个Map的Key是ThreadLocal实例本身，Value才是真正要存储的值Object，具体过程如下：

public class Thread implements Runnable {{
    ...
    ThreadLocal.ThreadLocalMap threadLocals = null;
    ...
}

1. 每个Thread线程内部都有一个Map（ThreadLocalMap）
2. Map里面存储ThreadLocal对象（Key）和线程的变量副本（Value）
3. Thread内部的Mao是由ThreadLocal维护的，由ThreadLocal负责向Map获取和设置线程的变量值
4. 对于不同的线程，每次获取副本值时，别的线程并不能获取当前线程的副本值，形成了副本的隔离，互
不干扰。

　　JDK8设计优点：

1. 每个Map存储的Entry数量减少，不再是一个Thread对应一个Entry。
2. 当Thread销毁的时候，ThreadLocalMao也随之销毁，减少内存的使用。早期ThreadLocalMao是由
ThreadLocal维护的，Thread销毁并不会使ThreadLocalMap销毁。

---

六、核心方法源码

6.1 set()

/**
    * 设置当前线程对应的ThreadLocal的值
    */
public void set(T value) {
    //获取当前线程对象
    Thread t = Thread.currentThread();
    //获取Thread维护的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    if (map != null)
        //map存在，则设置Entry
        map.set(this, value);
    else
        //1. 当前线程Thread不存在ThreadLocalMap对象
        //2.则调用createMap进行ThreadLocalMap初始化
        //3.并将Thread t（当前线程）和value作为第一个entry存放之ThreadLocalMap中
        createMap(t, value);
}
/**
    * 获取Thread维护的ThreadLocalMap对象，返回当前线程对应维护的ThreadLocalMap
    */
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}
/** 
     * 创建当前线程Thread对应维护的ThreadLocalMap
     * @param t 当前线程
     * @param  存放到Map的第一个Entry的值
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

6.2 get()

/**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    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;
            }
        }
        /*
            初始化：有两种情况执行此方法
                  1.map不存在，表示此线程没有维护的ThreadLocalMap对象
                  2.map存在，entry不存在

        */
        return setInitialValue();
    }

/**
     * @return the initial value
     */e
    private T setInitialValue() {
        //获取初始化值，此方法可被重写，如果不重写返回null
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //如果map存在，设置此实体entry
            map.set(this, value);
        else
            //当前线程Thread不存在ThreadLocalMap对象
            //则调用createMap进行初始化，并将当前线程和value作为第一个entry放入Map
            createMap(t, value);
        return value;
    }

　　总结：先获取当前线程的ThreadLoaclMap变量，如果存在则返回值，不存在则创建并返回初始值。

6.3 initiaValue()

protected T initialValue() {
        return null;
    }

　　 这个方法是一个延迟调用的方法，从上面的代码可知，在set方法还未调用之前调用了get方法时才会执行此方法，且只执行一次。这个方法缺省值返回一个null。如果想要除null之外的初始值，可以重写此方法。（该方法是一个protected方法，显然是为了让子类覆盖而设计的）。

6.4 remove()

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

---

七、ThreadLocalMap源码分析

7.1 基本结构

　　ThreadLocalMap是ThreadLocal内部类，没有实现Map接口，用独立的方法实现了Map的功能，其内部的Entry也是独立实现。

 7.1.1 默认属性

        /**
         * 初始容量 必须是2的整次幂
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * 存放数据
         * 数组长度为2的整次幂
         */
        private Entry[] table;

        /**
         * 数组中Entry的个数，可用于判断是否需要扩容
         */
        private int size = 0;

        /**
         * 扩容阈值
         */
        private int threshold; // Default to 0

7.1.2 存储结构-Entry

/**
         * Entry继承WeakReference，并且用ThreadLocal作为key。
         * 如果key为null（entry.get()==null），意味着key不再被引用
         *  因此这时Entry也可以从table中清除
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

　　Entry继承WeakReference，也就是key(ThreadLocal)是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

7.2 弱引用和内存泄漏

弱引用：只要垃圾回收器发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收他的内存。

　　Q1：如果Key使用强引用，那么会出现内存泄漏吗？

1. 假设在业务代码中使用完ThreadLocal, ThreadLocal ref被回收了
2. 但是因为threadLocalMap的Entry强引用了threadLocal, 造成ThreadLocal无法被回收
3. 在没有手动删除Entry以及CurrentThread依然运行的前提下, 始终有强引用链threadRef → currentThread →
 entry, Entry就不会被回收( Entry中包括了ThreadLocal实例和value), 导致Entry内存泄漏

也就是说: ThreadLocalMap中的key使用了强引用, 是无法完全避免内存泄漏的

 　　Q2：如果Key使用弱引用，那么会出现内存泄漏吗？

1. 假设在业务代码中使用完ThreadLocal, ThreadLocal ref被回收了
2. 由于threadLocalMap只持有ThreadLocal的弱引用, 没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收
,此时Entry中的key = null
3. 在没有手动删除Entry以及CurrentThread依然运行的前提下, 也存在有强引用链threadRef → currentThread → value, value就
不会被回收, 而这块value永远不会被访问到了, 导致value内存泄漏

也就是说: ThreadLocalMap中的key使用了弱引用, 也有可能内存泄漏。

　　由上可知，内存泄漏的发生跟 ThreadLocalIMap 中的 key 是否使用弱引用是没有关系的。那么内存泄漏的的真正原因是什么呢？

　　细心的同学会发现，在以上两种内存泄漏的情况中．都有两个前提：
　　　　1 ．没有手动侧除这个 Entry
　　　　2 · CurrentThread 依然运行
　　第一点很好理解，只要在使用完下 ThreadLocal ，调用其 remove 方法翻除对应的 Entry ，就能避免内存泄漏。
　　第二点稍微复杂一点，由于ThreodLocalMap 是 Threod 的一个属性，被当前线程所引用所以它的生命周期跟 Thread 一样长。那么在使用完 ThreadLocal 的使用，如果当前Thread 也随之执行结束， ThreadLocalMap 自然也会被 gc 回收，从根源上避免了内存泄漏。

　　综上， ThreadLocal 内存泄漏的根源是：由于ThreadLocalMap 的生命周期跟 Thread 一样长，如果没有手动删除对应 key 就会导致内存泄漏．

　　Q3：那为什么Key要使用弱引用呢？

　　为什么使用弱引用，根据刚才的分析，我们知道了：无论 ThreadLocalMap 中的 key 使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。

​　　 要避免内存泄漏有两种方式：
​　　　　 1 ．使用完 ThreadLocal ，调用其 remove 方法删除对应的 Entry
　　　　​ 2 ．使用完 ThreadLocal ，当前 Thread 也随之运行结束

​ 　　相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的．也就是说，只要记得在使用完ThreadLocal 及时的调用 remove ，无论 key 是强引用还是弱引用都不会有问题.

​ 　　事实上，在 ThreadLocalMap 中的set/getEntry 方法中，会对 key 为 null （也即是 ThreadLocal 为 null ）进行判断，如果为 null 的话，那么是会对 value 置为 null 的．

​　　 这就意味着使用完 ThreadLocal , CurrentThread 依然运行的前提下．就算忘记调用 remove 方法，弱引用比强引用可以多一层保障：弱引用的 ThreadLocal 会被回收．对应value在下一次 ThreadLocaIMap 调用 set/get/remove 中的任一方法的时候会被清除，从而避免内存泄漏。

7.3 Hash冲突的解决

7.3.1 从ThreadLocal的set()方法入手

　　回顾：

1. 首先获取当前线程，并根据当前线程获取一个Map
2. 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal作为Key），这里调用了ThreadLocalMap的set()方法。
3.如果Map为空，则给该线程创建Map，并设置初始量（这里调用了ThreadLoacalMap的构造方法）

7.3.2 构造方法：ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

/**
         * firstKey：本ThreadLocal实例
         * firstValue：要保存的线程本地变量
         */
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            //初始化table
            table = new Entry[INITIAL_CAPACITY];
            //计算索引（★★★★★）INITiTAL_CAPACITY初始值是16
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            //设置值
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            //设置阈值,是数组容量的2/3
            setThreshold(INITIAL_CAPACITY);
        }

　　分析：firstKey.threadLocalHashCode

private final int threadLocalHashCode = nextHashCode();

private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
//原子Integer，适合高并发
private static AtomicInteger nextHashCode = new AtomicInteger();
//16进制 特殊的hash值
private static final int HASH_INCREMENT = 0x61c88647;

public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

　　这里定义了一个AtomicInteger类型nextHashCode ，每次获取当前值并加上HASH_INCREMENT，值为0x61c88647，这个值跟斐波那契数列有关，其主要目的是为了让哈希码能均匀地分布在2的n次方数组里，也就是table中，减小哈希冲突。原来 hash code 从 0 开始不断累加 0x61c88647 生成的.。

　　分析：(INITIAL_CAPACITY - 1)

 　　计算hash的时候采用hashCode&(size-1)的算法，这相当于取模运算hashCode%size的一个更有效的实现。例如50%16 = 50&15，使用位运算比取余更快。所以size必须是2的整次幂。

7.3.3 ThreadLocalMap的set()方法

private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            //计算索引
            int i = key.threadLocalHashCode & (len-1);
            //线性探测法查找元素 ★★★★★
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                //取出Key
                ThreadLocal<?> k = e.get();
                //ThreadLocal对应的值存在，则覆盖之前的值
                if (k == key) {
                    e.value = value;
                    return;
                }
                //key为null，但是值不为null，说明之前的ThreadLocal对象已经被回收了
                //当前数组中的Entry是一个陈旧的元素
                if (k == null) {
                    //用新元素替代陈旧的元素，这个方法进行了不少垃圾清理的动作，防止内存泄漏
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //ThreadLocal对应的Key不存在并且没有找到陈旧的值，
            //则在空元素位置创建一个新的Entry
            tab[i] = new Entry(key, value);
            int sz = ++size;

            /**
              cleanSomeSlots用于清除那些e.get()==null的元素
              这种数据key关联的对象已经被回收，所以这个Entry(table[index])
               可以被置为null，如果没有清除任何Entry，并且当前使用量达到了负
              载因子所定义（长度的2/3），那么进行rehash操作（执行一次全表的扫描清理 
              工作）

            */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
//获取环形数组的下一个索引
private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }