1. 什么是ThreadLocal

声明：本文使用的是JDK 1.8

首先我们来看一下JDK的文档介绍：

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

结合我的总结可以这样理解：ThreadLocal提供了线程的局部变量，每个线程都可以通过set()和get()来对这个局部变量进行操作，但不会和其他线程的局部变量进行冲突，实现了线程的数据隔离～。
简要言之：往ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。

2. 为什么要学习ThreadLocal？

从上面可以得出：ThreadLocal可以让我们拥有当前线程的变量，那这个作用有什么用呢？？？

2.1管理Connection

最典型的是管理数据库的Connection：当时在学JDBC的时候，为了方便操作写了一个简单数据库连接池，需要数据库连接池的理由也很简单，频繁创建和关闭Connection是一件非常耗费资源的操作，因此需要创建数据库连接池～
那么，数据库连接池的连接怎么管理呢？？我们交由ThreadLocal来进行管理。为什么交给它来管理呢？？ThreadLocal能够实现当前线程的操作都是用同一个Connection，保证了事务！
当时候写的代码：

  1. public class DBUtil {
  2.     //数据库连接池
  3.     private static BasicDataSource source;
  4.     //为不同的线程管理连接
  5.     private static ThreadLocal<Connection> local;
  6.     static {
  7.         try {
  8.             //加载配置文件
  9.             Properties properties = new Properties();
  10.             //获取读取流
  11.             InputStream stream = DBUtil.class.getClassLoader().getResourceAsStream("连接池/config.properties");
  12.             //从配置文件中读取数据
  13.             properties.load(stream);
  14.             //关闭流
  15.             stream.close();
  16.             //初始化连接池
  17.             source = new BasicDataSource();
  18.             //设置驱动
  19.             source.setDriverClassName(properties.getProperty("driver"));
  20.             //设置url
  21.             source.setUrl(properties.getProperty("url"));
  22.             //设置用户名
  23.             source.setUsername(properties.getProperty("user"));
  24.             //设置密码
  25.             source.setPassword(properties.getProperty("pwd"));
  26.             //设置初始连接数量
  27.             source.setInitialSize(Integer.parseInt(properties.getProperty("initsize")));
  28.             //设置最大的连接数量
  29.             source.setMaxActive(Integer.parseInt(properties.getProperty("maxactive")));
  30.             //设置最长的等待时间
  31.             source.setMaxWait(Integer.parseInt(properties.getProperty("maxwait")));
  32.             //设置最小空闲数
  33.             source.setMinIdle(Integer.parseInt(properties.getProperty("minidle")));
  34.             //初始化线程本地
  35.             local = new ThreadLocal<>();
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         }
  39.     }
  40.     public static Connection getConnection() throws SQLException {
  42.         if(local.get()!=null){
  43.             return local.get();
  44.         }else{
  46.             //获取Connection对象
  47.             Connection connection = source.getConnection();
  49.             //把Connection放进ThreadLocal里面
  50.             local.set(connection);
  52.             //返回Connection对象
  53.             return connection;
  54.         }
  55.     }
  56.     //关闭数据库连接
  57.     public static void closeConnection() {
  58.         //从线程中拿到Connection对象
  59.         Connection connection = local.get();
  60.         try {
  61.             if (connection != null) {
  62.                 //恢复连接为自动提交
  63.                 connection.setAutoCommit(true);
  64.                 //这里不是真的把连接关了,只是将该连接归还给连接池
  65.                 connection.close();
  66.                 //既然连接已经归还给连接池了,ThreadLocal保存的Connction对象也已经没用了
  67.                 local.remove();
  68.             }
  69.         } catch (SQLException e) {
  70.             e.printStackTrace();
  71.         }
  72.     }
  73. }

同样的，Hibernate对Connection的管理也是采用了相同的手法(使用ThreadLocal，当然了Hibernate的实现是更强大的)～

2.2避免一些参数传递

避免一些参数的传递的理解可以参考一下Cookie和Session：

  • 每当我访问一个页面的时候，浏览器都会帮我们从硬盘中找到对应的Cookie发送过去。
  • 浏览器是十分聪明的，不会发送别的网站的Cookie过去，只带当前网站发布过来的Cookie过去

浏览器就相当于我们的ThreadLocal，它仅仅会发送我们当前浏览器存在的Cookie(ThreadLocal的局部变量)，不同的浏览器对Cookie是隔离的(Chrome,Opera,IE的Cookie是隔离的【在Chrome登陆了，在IE你也得重新登陆】)，同样地：线程之间ThreadLocal变量也是隔离的….
那上面避免了参数的传递了吗？？其实是避免了。Cookie并不是我们手动传递过去的，并不需要写<input name= cookie/>来进行传递参数…
在编写程序中也是一样的：日常中我们要去办理业务可能会有很多地方用到身份证，各类证件，每次我们都要掏出来很麻烦

  1. // 咨询时要用身份证，学生证，房产证等等....
  2.     public void consult(IdCard idCard,StudentCard studentCard,HourseCard hourseCard){
  3.     }
  4.     // 办理时还要用身份证，学生证，房产证等等....
  5.     public void manage(IdCard idCard,StudentCard studentCard,HourseCard hourseCard) {
  6.     }
  7.     //......

而如果用了ThreadLocal的话，ThreadLocal就相当于一个机构，ThreadLocal机构做了记录你有那么多张证件。用到的时候就不用自己掏了，问机构拿就可以了。
在咨询时的时候就告诉机构：来，把我的身份证、房产证、学生证通通给他。在办理时又告诉机构：来，把我的身份证、房产证、学生证通通给他。…

  1. // 咨询时要用身份证，学生证，房产证等等....
  2.     public void consult(){
  3.         threadLocal.get();
  4.     }
  5.     // 办理时还要用身份证，学生证，房产证等等....
  6.     public void takePlane() {
  7.         threadLocal.get();
  8.     }
  9. 复制代码

这样是不是比自己掏方便多了。
当然了，ThreadLocal可能还会有其他更好的作用，如果知道的同学可在评论留言哦～～～

3. ThreadLocal实现的原理

想要更好地去理解ThreadLocal，那就得翻翻它是怎么实现的了～～～

声明：本文使用的是JDK 1.8

首先，我们来看一下ThreadLocal的set()方法，因为我们一般使用都是new完对象，就往里边set对象了

  1. public void set(T value) {
  2.         // 得到当前线程对象
  3.         Thread t = Thread.currentThread();
  5.         // 这里获取ThreadLocalMap
  6.         ThreadLocalMap map = getMap(t);
  7.         // 如果map存在，则将当前线程对象t作为key，要存储的对象作为value存到map里面去
  8.         if (map != null)
  9.             map.set(this, value);
  10.         else
  11.             createMap(t, value);
  12.     }

上面有个ThreadLocalMap，我们去看看这是什么？

  1. static class ThreadLocalMap {
  2.         /**
  3.          * The entries in this hash map extend WeakReference, using
  4.          * its main ref field as the key (which is always a
  5.          * ThreadLocal object).  Note that null keys (i.e. entry.get()
  6.          * == null) mean that the key is no longer referenced, so the
  7.          * entry can be expunged from table.  Such entries are referred to
  8.          * as "stale entries" in the code that follows.
  9.          */
  10.         static class Entry extends WeakReference<ThreadLocal<?>> {
  11.             /** The value associated with this ThreadLocal. */
  12.             Object value;
  13.             Entry(ThreadLocal<?> k, Object v) {
  14.                 super(k);
  15.                 value = v;
  16.             }
  17.         }
  18.         //....
  19. }

通过上面我们可以发现的是ThreadLocalMap是ThreadLocal的一个内部类。用Entry类来进行存储
我们的值都是存储到这个Map上的，key是当前ThreadLocal对象！
如果该Map不存在，则初始化一个：

  1. void createMap(Thread t, T firstValue) {
  2.         t.threadLocals = new ThreadLocalMap(this, firstValue);
  3.     }

如果该Map存在，则从Thread中获取！

  1. /**
  2.      * Get the map associated with a ThreadLocal. Overridden in
  3.      * InheritableThreadLocal.
  4.      *
  5.      * @param  t the current thread
  6.      * @return the map
  7.      */
  8.     ThreadLocalMap getMap(Thread t) {
  9.         return t.threadLocals;
  10.     }

Thread维护了ThreadLocalMap变量

  1. /* ThreadLocal values pertaining to this thread. This map is maintained
  2.      * by the ThreadLocal class. */
  3.     ThreadLocal.ThreadLocalMap threadLocals = null

从上面又可以看出，ThreadLocalMap是在ThreadLocal中使用内部类来编写的，但对象的引用是在Thread中！
于是我们可以总结出：Thread为每个线程维护了ThreadLocalMap这么一个Map，而ThreadLocalMap的key是LocalThread对象本身，value则是要存储的对象
有了上面的基础，我们看get()方法就一点都不难理解了：

  1. public T get() {
  2.         Thread t = Thread.currentThread();
  3.         ThreadLocalMap map = getMap(t);
  4.         if (map != null) {
  5.             ThreadLocalMap.Entry e = map.getEntry(this);
  6.             if (e != null) {
  7.                 @SuppressWarnings("unchecked")
  8.                 T result = (T)e.value;
  9.                 return result;
  10.             }
  11.         }
  12.         return setInitialValue();
  13.     }

3.1ThreadLocal原理总结

  1. 每个Thread维护着一个ThreadLocalMap的引用
  2. ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储
  3. 调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值是传递进来的对象
  4. 调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象
  5. ThreadLocal本身并不存储值，它只是作为一个key来让线程从ThreadLocalMap获取value。

正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响～

4. 避免内存泄露

我们来看一下ThreadLocal的对象关系引用图：
ThreadLocal - 图1
ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。
想要避免内存泄露就要手动remove()掉！

5. 总结

最后要记住的是:ThreadLocal设计的目的就是为了能够在当前线程中有属于自己的变量，并不是为了解决并发或者共享变量的问题

6. 参考链接：

https://juejin.im/post/5ac2eb52518825555e5e06ee