ThreadLocal就是这么简单

时间  2020-02-27
标签 threadlocal 就是 简单 栏目 Java 繁體版
原文   原文链接

前言

今天要研究的是ThreadLocal，这个我在一年前学习JavaWeb基础的时候接触过一次，当时在baidu搜出来的第一篇博文ThreadLocal，在评论下不少开发者认为那博主理解错误，给出了不少有关的连接来指正(可原博主可能没上博客了，一直没作修改)。我也去学习了一番，惋惜的是当时尚未记录的习惯，直到如今仅仅记住了一些当时学过的皮毛。html

所以，作一些技术的记录是很重要的～同时，ThreadLocal也是面试很是常见的面试题，对Java开发者而言也是一个必要掌握的知识点～java

固然了，若是我有写错的地方请你们多多包涵，欢迎在评论下留言指正～面试

1、什么是ThreadLocal

声明：本文使用的是JDK 1.8

首先咱们来看一下JDK的文档介绍：数据库

/**
 * 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.
 */

结合个人总结能够这样理解：ThreadLocal提供了线程的局部变量，每一个线程均可以经过set()和get()来对这个局部变量进行操做，但不会和其余线程的局部变量进行冲突，实现了线程的数据隔离～。浏览器

简要言之：往ThreadLocal中填充的变量属于当前线程，该变量对其余线程而言是隔离的。微信

2、为何要学习ThreadLocal？

从上面能够得出：ThreadLocal可让咱们拥有当前线程的变量，那这个做用有什么用呢？？？cookie

2.1管理Connection

最典型的是管理数据库的Connection：当时在学JDBC的时候，为了方便操做写了一个简单数据库链接池，须要数据库链接池的理由也很简单，频繁建立和关闭Connection是一件很是耗费资源的操做，所以须要建立数据库链接池～并发

那么，数据库链接池的链接怎么管理呢？？咱们交由ThreadLocal来进行管理。为何交给它来管理呢？？ThreadLocal可以实现当前线程的操做都是用同一个Connection，保证了事务！ide

当时候写的代码：post

public class DBUtil {
    //数据库链接池
    private static BasicDataSource source;

    //为不一样的线程管理链接
    private static ThreadLocal<Connection> local;


    static {
        try {
            //加载配置文件
            Properties properties = new Properties();

            //获取读取流
            InputStream stream = DBUtil.class.getClassLoader().getResourceAsStream("链接池/config.properties");

            //从配置文件中读取数据
            properties.load(stream);

            //关闭流
            stream.close();

            //初始化链接池
            source = new BasicDataSource();

            //设置驱动
            source.setDriverClassName(properties.getProperty("driver"));

            //设置url
            source.setUrl(properties.getProperty("url"));

            //设置用户名
            source.setUsername(properties.getProperty("user"));

            //设置密码
            source.setPassword(properties.getProperty("pwd"));

            //设置初始链接数量
            source.setInitialSize(Integer.parseInt(properties.getProperty("initsize")));

            //设置最大的链接数量
            source.setMaxActive(Integer.parseInt(properties.getProperty("maxactive")));

            //设置最长的等待时间
            source.setMaxWait(Integer.parseInt(properties.getProperty("maxwait")));

            //设置最小空闲数
            source.setMinIdle(Integer.parseInt(properties.getProperty("minidle")));

            //初始化线程本地
            local = new ThreadLocal<>();


        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        if(local.get()!=null){
            return local.get();
        }else{
        
          //获取Connection对象
          Connection connection = source.getConnection();

          //把Connection放进ThreadLocal里面
          local.set(connection);

          //返回Connection对象
          return connection;
       }
    }

    //关闭数据库链接
    public static void closeConnection() {
        //从线程中拿到Connection对象
        Connection connection = local.get();

        try {
            if (connection != null) {
                //恢复链接为自动提交
                connection.setAutoCommit(true);

                //这里不是真的把链接关了,只是将该链接归还给链接池
                connection.close();

                //既然链接已经归还给链接池了,ThreadLocal保存的Connction对象也已经没用了
                local.remove();

            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


}

一样的，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/>来进行传递参数...

在编写程序中也是同样的：平常中咱们要去办理业务可能会有不少地方用到身份证，各种证件，每次咱们都要掏出来很麻烦

// 咨询时要用身份证，学生证，房产证等等....
    public void consult(IdCard idCard,StudentCard studentCard,HourseCard hourseCard){

    }

    // 办理时还要用身份证，学生证，房产证等等....
    public void manage(IdCard idCard,StudentCard studentCard,HourseCard hourseCard) {

    }

    //......

而若是用了ThreadLocal的话，ThreadLocal就至关于一个机构，ThreadLocal机构作了记录你有那么多张证件。用到的时候就不用本身掏了，问机构拿就能够了。

在咨询时的时候就告诉机构：来，把个人身份证、房产证、学生证统统给他。在办理时又告诉机构：来，把个人身份证、房产证、学生证统统给他。...

// 咨询时要用身份证，学生证，房产证等等....
    public void consult(){

        threadLocal.get();
    }

    // 办理时还要用身份证，学生证，房产证等等....
    public void takePlane() {
        threadLocal.get();
    }

这样是否是比本身掏方便多了。

固然了，ThreadLocal可能还会有其余更好的做用，若是知道的同窗可在评论留言哦～～～

3、ThreadLocal实现的原理

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

声明：本文使用的是JDK 1.8

首先，咱们来看一下ThreadLocal的set()方法，由于咱们通常使用都是new完对象，就往里边set对象了

public void set(T value) {

        // 获得当前线程对象
        Thread t = Thread.currentThread();
        
        // 这里获取ThreadLocalMap
        ThreadLocalMap map = getMap(t);

        // 若是map存在，则将当前对象threadLocal做为key，要存储的对象做为value存到map里面去
        if (map != null)
            map.set(this, value);
        else
            // 若是map不存在，则在当前线程中建立出一个ThreadLocalMap！
            createMap(t, value);
    }

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

static class ThreadLocalMap {

        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

经过上面咱们能够发现的是ThreadLocalMap是ThreadLocal的一个内部类。用Entry类来进行存储

咱们的值都是存储到这个Map上的，key是当前ThreadLocal对象！

若是该Map不存在，则初始化一个：

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

若是该Map存在，则从Thread中获取！

/**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

Thread维护了ThreadLocalMap变量

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

从上面又能够看出，ThreadLocalMap是在ThreadLocal中使用内部类来编写的，但对象的引用是在Thread中！

因而咱们能够总结出：Thread为每一个线程维护了ThreadLocalMap这么一个Map，而ThreadLocalMap的key是ThreadLocal对象自己，value则是要存储的对象

有了上面的基础，咱们看get()方法就一点都不难理解了：

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

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内存泄漏的根源是：因为ThreadLocalMap的生命周期跟Thread同样长，若是没有手动删除对应key就会致使内存泄漏，而不是由于弱引用。

想要避免内存泄露就要手动remove()掉！

5、总结

ThreadLocal这方面的博文真的是数不胜数，随便一搜就不少不少～站在前人的肩膀上总结了这篇博文～

最后要记住的是:ThreadLocal设计的目的就是为了可以在当前线程中有属于本身的变量，并非为了解决并发或者共享变量的问题

若是看得不够过瘾，以为不够深刻的同窗可参考下面的连接，不少的博主还开展了一些扩展知识，我就不一一展开了～

参考博文：

若是文章有错的地方欢迎指正，你们互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同窗，能够 关注微信公众号:Java3y
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程