ThreadLocal 详解

ThreadLocal 详解

目录

ThreadLocal 详解

1、ThreadLocal 简介

2、ThreadLocal 的使用

3、实现原理--重要源码分析

4、使用Thread需要注意的内存泄露问题。

5、ThreadLocal 的应用场景

6、总结

---

精彩博客：https://mp.weixin.qq.com/s/8Ql-5kaUtxiCWyHR6uPPBw

---

1、ThreadLocal 简介

多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。

　　ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一乐ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题。

       简单的说就是ThreadLocal是线程Thread中属性threadLocals的管理者。通过ThreadLocal我们可以给每个独立的线程实现操作自己内存变量的操作。也就是说我们对于ThreadLocal的get, set，remove的操作结果都是针对当前线程Thread实例的threadLocals存，取，删除操作。

2、ThreadLocal 的使用

下面的例子中，开启两个线程，在每个线程内部设置了本地变量的值，然后调用print方法打印当前本地变量的值。如果在打印之后调用本地变量的remove方法会删除本地内存中的变量

package 美团笔试;

public class TestThreadLocal {

    static ThreadLocal<String> local = new ThreadLocal<>();  //创建ThreadLocal

    static void print(){
        System.out.println(Thread.currentThread() + "获取自己的线程内存变量-----" + local.get());
        local.remove();  
    }

    public static void main(String args[]){
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                local.set("测试ThreadLocal hhhhh");  //设置线程变量值
                print();
                System.out.println("remove后为-----" + local.get());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                local.set("测试ThreadLocal xxxxx");  //设置线程变量值
                print();
                System.out.println("remove后" + local.get());
            }
        });
        thread1.start();
        thread2.start();
    }

}

结果：

Thread[Thread-0,5,main]获取自己的线程内存变量-----测试ThreadLocal hhhhh
Thread[Thread-1,5,main]获取自己的线程内存变量-----测试ThreadLocal xxxxx
remove后null
remove后为-----null

3、实现原理--重要源码分析

3.1 类结构图如下

3.2 源码分析

（1）set 方法

public void set(T value) {
    //(1)获取当前线程（调用者线程）
    Thread t = Thread.currentThread();
    //(2)以当前线程作为key值，去查找对应的线程变量，找到对应的map
    ThreadLocalMap map = getMap(t);
    //(3)如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
    if (map != null)
        map.set(this, value);
    //(4)如果map为null，说明首次添加，需要首先创建出对应的map
    else
        createMap(t, value);
}

 在上面的代码中，(2)处调用getMap方法获得当前线程对应的threadLocals(参照上面的图示和文字说明)，该方法代码如下

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals; //获取线程自己的变量threadLocals，并绑定到当前调用线程的成员变量threadLocals上
}

如果调用getMap方法返回值不为null，就直接将value值设置到threadLocals中（key为当前线程引用，值为本地变量）；如果getMap方法返回null说明是第一次调用set方法（前面说到过，threadLocals默认值为null，只有调用set方法的时候才会创建map），这个时候就需要调用createMap方法创建threadLocals，该方法如下所示

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

createMap方法不仅创建了threadLocals，同时也将要添加的本地变量值添加到了threadLocals中。

总结：调用set()方法，实际上就是从当前线程中获取本身的threadLocals，并把相应的值设置进去。

（2）get 方法

 在get方法的实现中，首先获取当前调用者线程，如果当前线程的threadLocals不为null，就直接返回当前线程绑定的本地变量值，否则执行setInitialValue方法初始化threadLocals变量。在setInitialValue方法中，类似于set方法的实现，都是判断当前线程的threadLocals变量是否为null，是则添加本地变量（这个时候由于是初始化，所以添加的值为null），否则创建threadLocals变量，同样添加的值为null。

public T get() {
    //(1)获取当前线程
    Thread t = Thread.currentThread();
    //(2)获取当前线程的threadLocals变量
    ThreadLocalMap map = getMap(t);
    //(3)如果threadLocals变量不为null，就可以在map中查找到本地变量的值
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //(4)执行到此处，threadLocals为null，调用该更改初始化当前线程的threadLocals变量
    return setInitialValue();
}

private T setInitialValue() {
    //protected T initialValue() {return null;}
    T value = initialValue();
    //获取当前线程
    Thread t = Thread.currentThread();
    //以当前线程作为key值，去查找对应的线程变量，找到对应的map
    ThreadLocalMap map = getMap(t);
    //如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
    if (map != null)
        map.set(this, value);
    //如果map为null，说明首次添加，需要首先创建出对应的map
    else
        createMap(t, value);
    return value;
}

（3）remove 方法

remove方法判断该当前线程对应的threadLocals变量是否为null，不为null就直接删除当前线程中指定的threadLocals变量

public void remove() {
    //获取当前线程绑定的threadLocals
     ThreadLocalMap m = getMap(Thread.currentThread());
     //如果map不为null，就移除当前线程中指定ThreadLocal实例的本地变量
     if (m != null)
         m.remove(this);
 }

3.3 小总结

ThreadLocal及Thread之间的关系：

 

从这张图我们可以直观的看到Thread中属性threadLocals，作为一个特殊的Map，它的key值就是我们ThreadLocal实例，而value值这是我们设置的值。

 

4、使用Thread需要注意的内存泄露问题。

4.1 基本概念

Memory overflow:内存溢出，没有足够的内存提供申请者使用。
Memory leak:内存泄漏，程序申请内存后，无法释放已申请的内存空间，内存泄漏的堆积终将导致内存溢出。

4种引用的概念：

4.2 来看一下Entry类

      static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;

            Entry(ThreadLocal<?> var1, Object var2) {
                super(var1);
                this.value = var2;
            }
        }

  可见其继承了WeakReference类，是弱引用。

4.3 看一下ThreadLocal里面的弱引用

可以推测得出，如果ThreadLocal 类被GC 掉了，那么Entry节点将无法被访问到了。但因为Entry含有一条强引用链：

Threadred --》 Thread --》ThreadLocal.ThreadLocalMap --》Entry ,所以如果Entry大量积累的话就有可能发生内存泄露的问题。

 

4.4 解决问题和小总结

     总结了使用ThreadLocal时会发生内存泄漏的前提条件：
         （1）ThreadLocal引用被设置为null，且后面没有set，get,remove操作。
         （2）线程一直运行，不停止。（线程池）
         （3）触发了垃圾回收。（Minor GC或Full GC）

    我们看到ThreadLocal出现内存泄漏条件还是很苛刻的，所以我们只要破坏其中一个条件就可以避免内存泄漏，单但为了更好的避免这种情况的发生我们使用ThreadLocal时遵守以下两个小原则:
    （1）ThreadLocal申明为private static final。
             Private与final 尽可能不让他人修改变更引用，
             Static 表示为类属性，只有在程序结束才会被回收。
    （2）ThreadLocal使用后务必调用remove方法。
             最简单有效的方法是使用后将其移除。

 

5、ThreadLocal 的应用场景

最典型的就是管理数据库连接池了。

那么，数据库连接池的连接怎么管理呢？？我们交由ThreadLocal来进行管理。为什么交给它来管理呢？？ThreadLocal能够实现当前线程的操作都是用同一个Connection，保证了事务！

大致代码：

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();
        }
        // finally 这里也需要关闭 connection 和 remove  local

    }


}

6、总结

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

参考：

https://blog.csdn.net/zzg1229059735/article/details/82715741