Java中ThreadLocal的一些理解

前言

面试的时候被问到ThreadLocal的相关知识,没有回答好(奶奶的,现在感觉问啥都能被问倒),所以我决定先解决这几次面试中都遇到的高频问题,把这几个硬骨头都能理解的透彻的说出来了,感觉最起码不能总是一轮游。

ThreadLocal介绍

ThreadLocal是JDK1.2开始就提供的一个用来存储线程本地变量的类。ThreadLocal中的变量是在每个线程中独立存在的,当多个线程访问ThreadLocal中的变量的时候,其实都是访问的自己当前线程的内存中的变量,从而保证的变量的线程安全。

我们一般在使用ThreadLocal的时候都是为了解决线程中存在的变量竞争问题。其实解决这类问题,通常大家也会想到使用synchronized来加锁解决。

例如在解决SimpleDateFormat的线程安全的时候。SimpleDateFormat是非线程安全的,它里面无论的是format()方法还是parse()方法,都有使用它自己内部的一个Calendar类的对象,format方法是设置时间,parse()方法里面是先调用Calendar的clear()方法,然后又调用了Calendar的set()方法(赋值),如果一个线程刚调用了set()进行赋值,这个时候又来了一个线程直接调用了clear()方法,那么这个parse()方法执行的结果就会有问题的。

解决办法一
将使用SimpleDateformat的方法加上synchronized,这样虽然保证了线程安全,但却降低了效率,同一时间只有一个线程能使用格式化时间的方法。

private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

public static synchronized String formatDate(Date date){
  return simpleDateFormat.format(date);
}

解决办法二
将SimpleDateFormat的对象,放到ThreadLocal里面,这样每个线程中都有一个自己的格式对象的副本了。互不干扰,从而保证了线程安全。

private static final ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

public static String formatDate(Date date){
  return simpleDateFormatThreadLocal.get().format(date);
}

ThreadLocal的原理

我们先看一下ThreadLocal是怎么使用的。

ThreadLocal<Integer> threadLocal99 = new ThreadLocal<Integer>();
threadLocal99.set(3);
int num = threadLocal99.get();
System.out.println("数字:"+num);
threadLocal99.remove();
System.out.println("数字Empty:"+threadLocal99.get());

运行结果:

数字:3
数字Empty:null

使用起来很简单,主要是将变量放到ThreadLocal里面,在线程执行过程中就可以取到,当执行完成后在remove掉就可以了,只要没有调用remove()当前线程在执行过程中都是可以拿到变量数据的。
因为是放到了当前执行的线程中,所以ThreadLocal中的变量值只能当前线程来使用,从而保证的了线程安全(当前线程的子线程其实也是可以获取到的)。

来看一下ThreadLocal的set()方法源码

public void set(T value) {
  // 获取当前线程
  Thread t = Thread.currentThread();
  // 获取ThreadLocalMap
  ThreadLocal.ThreadLocalMap map = getMap(t);
  // ThreadLocalMap 对象是否为空,不为空则直接将数据放入到ThreadLocalMap中
  if (map != null)
    map.set(this, value);
  else
    createMap(t, value); // ThreadLocalMap对象为空,则先创建对象,再赋值。
}

我们看到变量都是存放在了ThreadLocalMap这个变量中的。那么ThreadLocalMap又是怎么来的呢?

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

通过上面的源码,我们发现ThreadLocalMap变量是当前执行线程中的一个变量,所以说,ThreadLocal中存放的数据其实都是放到了当前执行线程中的一个变量里面了。也就是存储在了当前的线程对象里了,别的线程里面是另一个线程对象了,拿不到其他线程对象中的数据,所以数据自然就隔离开了。

那么ThreadLocalMap是怎么存储数据的呢?
ThreadLocalMap 是ThreadLocal类里的一个内部类,虽然类的名字上带着Map但却没有实现Map接口,只是结构和Map类似而已。

ThreadLocalMap内部其实是一个Entry数组,Entry是ThreadLocalMap中的一个内部类,继承自WeakReference,并将ThreadLocal类型的对象设置为了Entry的Key,以及对Key设置成弱引用。
ThreadLocalMap的内部数据结构,就大概是这样的key,value组成的Entry的数组集合。

和真正的Map还是有区别的,没有链表了,这样在解决key的hash冲突的时候措施肯定就和HashMap不一样了。
一个线程中是可以创建多个ThreadLocal对象的,多个ThreadLocal对象就会存放多个数据,那么在ThreadLocalMap中就会以数组的形式存放这些数据。
我们来看一下具体的ThreadLocalMap的set()方法的源码

/**
 * Set the value associated with key.
 * @param key the thread local object
 * @param value the value to be set
 */
private void set(ThreadLocal<?> key, Object value) {

  // We don't use a fast path as with get() because it is at
  // least as common to use set() to create new entries as
  // it is to replace existing ones, in which case, a fast
  // path would fail more often than not.

  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)]) {
    ThreadLocal<?> k = e.get();
    // 如果当前位置不为空,并且当前位置的key和传过来的key相等,那么就会覆盖当前位置的数据
    if (k == key) {
      e.value = value;
      return;
    }
    // 如果当前位置为空,则初始化一个Entry对象,放到当前位置。
    if (k == null) {
      replaceStaleEntry(key, value, i);
      return;
    }
  }
  // 如果当前位置不为空,并且当前位置的key也不等于要赋值的key ,那么将去找下一个空位置,直接将数据放到下一个空位置处。
  tab[i] = new Entry(key, value);
  int sz = ++size;
  if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();
}

我们从set()方法中可以看到,处理逻辑有四步。

  • 第一步先根据Threadlocal对象的hashcode和数组长度做与运算获取数据应该放在当前数组中的位置。
  • 第二步就是判断当前位置是否为空,为空的话就直接初始化一个Entry对象,放到当前位置。
  • 第三步如果当前位置不为空,而当前位置的Entry中的key和传过来的key一样,那么直接覆盖掉当前位置的数据。
  • 第四步如果当前位置不为空,并且当前位置的Entry中的key和传过来的key
  • 也不一样,那么就会去找下一个空位置,然后将数据存放到空位置(数组超过长度后,会执行扩容的);

在get的时候也是类似的逻辑,先通过传入的ThreadLocal的hashcode获取在Entry数组中的位置,然后拿当前位置的Entry的Key和传入的ThreadLocal对比,相等的话,直接把数据返回,如果不相等就去判断和数组中的下一个值的key是否相等。。。

private Entry getEntry(ThreadLocal<?> key) {
  int i = key.threadLocalHashCode & (table.length - 1);
  Entry e = table[i];
  if (e != null && e.get() == key)
    return e;
  else
    return getEntryAfterMiss(key, i, e);
}
/**
 * Version of getEntry method for use when key is not found in
 * its direct hash slot.
 *
 * @param key the thread local object
 * @param i the table index for key's hash code
 * @param e the entry at table[i]
 * @return the entry associated with key, or null if no such
 */
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
  Entry[] tab = table;
  int len = tab.length;

  while (e != null) {
    ThreadLocal<?> k = e.get();
    if (k == key)
      return e;
    if (k == null)
      expungeStaleEntry(i);
    else
      i = nextIndex(i, len);
    e = tab[i];
  }
  return null;
}

我们上文一直说,ThreadLocal是保存在单个线程中的数据,每个线程都有自己的数据,但是实际ThreadLocal里面的真正的对象数据,其实是保存在堆里面的,而线程里面只是存储了对象的引用而已。
并且我们在使用的时候通常需要在上一个线程执行的方法的上下文共享ThreadLocal中的变量。
例如我的主线程是在某个方法中执行代码呢,但是这个方法中有一段代码时新创建了一个线程,在这个线程里面还使用了我这个正在执行的方法里面的定义的ThreadLocal里面的变量。这个时候,就是需要从新线程里面调用外面线程的数据,这个就需要线程间共享了。这种子父线程共享数据的情况,ThreadLocal也是支持的。
例如:

 ThreadLocal threadLocalMain = new InheritableThreadLocal();
 threadLocalMain.set("主线程变量");
 Thread t = new Thread() {
   @Override
   public void run() {
     super.run();
     System.out.println( "现在获取的变量是 =" + threadLocalMain.get());
   }
 };
 t.start();

运行结果:

现在获取的变量是 =主线程变量

上面这样的代码就能实现子父线程共享数据的情况,重点是使用InheritableThreadLocal来实现的共享。
那么它是怎么实现数据共享的呢?
在Thread类的init()方法中有这么一段代码:

if (inheritThreadLocals && parent.inheritableThreadLocals != null)
      this.inheritableThreadLocals =ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

这段代码的意思是,在创建线程的时候,如果当前线程的inheritThreadLocals变量和父线程的inheritThreadLocals变量都不为空的时候,会将父线程的inheritThreadLocals变量中的数据,赋给当前线程中的inheritThreadLocals变量。

ThreadLocal的内存泄漏问题
上文我们也提到过,ThreadLocal中的ThreadLocalMap里面的Entry对象是继承自WeakReference类的,说明Entry的key是一个弱引用。

弱引用是用来描述那些非必须的对象,弱引用的对象,只能生存到下一次垃圾收集发生为止。当垃圾收集器开始工作,无论当前内存是否足够,都会回收掉只被弱引用关联的对象。

这个弱引用还是ThreadLocal对象本身,所以一般在线程执行完成后,ThreadLocal对象就会变成null了,而为null的弱引用对象,在下一次GC的时候就会被清除掉,这样Entry的Key的内存空间就被释放出来了,但是Entry的value还在占用的内存,如果线程是被复用的(例如线程池中的线程),那么这里面的value值就会越来越多,最终就导致了内存泄漏。

防止内存泄漏的办法就是在每次使用完ThreadLocal的时候都去执行以下remove()方法,就可以把key和value的空间都释放了。

那既然容易产生内存泄漏,为什么还要设置成弱引用的呢?
如果正常情况下应该是强引用,但是强引用只要引用关系还在就一直不会被回收,所以如果线程被复用了,那么Entry中的Key和Value都不会被回收,这样就造成了Key和Value都会发生内存泄漏了。

以上就是Java中ThreadLocal的一些理解的详细内容,更多关于Java ThreadLocal的资料请关注我们其它相关文章!

时间: 2020-12-06

java线程本地变量ThreadLocal详解

介绍 ThreadLocal作为JDK1.2以来的一个java.lang包下的一个类,在面试和工程中都非常重要,这个类的主要目的是提供线程本地的变量,所以也有很多地方把这个类叫做线程本地变量 从字面理解,这个类为每个线程都创建了一个本地变量,实际上是ThreadLocal为变量在每个线程中都创建了一个副本,使得每个线程都可以访问自己内部的副本变量 通常提到多线程,都会考虑变量同步的问题,但是ThreadLocal并不是为了解决多线程共享变量同步的问题,而是为了让每个线程的变量不互相影响,相当于线

Java单线程ThreadLocal串值问题解决方案

ThreadLocal ThreadLocal 适用于变量在线程间隔离,而在方法或类间共享的场景. 代码 @RestController public class ThreadLocalController { private static final ThreadLocal<String> currentUid = ThreadLocal.withInitial(() -> null); @GetMapping("bad") public Map doBad(@Re

ThreadLocal使用案例_动力节点Java学院整理

用户提出一个需求:当修改产品价格的时候,需要记录操作日志,什么时候做了什么事情. 想必这个案例,只要是做过应用系统的小伙伴们,都应该遇到过吧?无外乎数据库里就两张表:product 与 log,用两条 SQL 语句应该可以解决问题: update product set price = ? where id = ? insert into log (created, description) values (?, ?) But!要确保这两条 SQL 语句必须在同一个事务里进行提交,否则有可能 u

java ThreadLocal使用案例详解

本文借由并发环境下使用线程不安全的SimpleDateFormat优化案例,帮助大家理解ThreadLocal. 最近整理公司项目,发现不少写的比较糟糕的地方,比如下面这个: public class DateUtil { private final static SimpleDateFormat sdfyhm = new SimpleDateFormat( "yyyyMMdd"); public synchronized static Date parseymdhms(String

java多线程编程之InheritableThreadLocal

InheritableThreadLocal的作用: 当我们需要在子线程中使用父线程中的值得时候我们就可以像使用ThreadLocal那样来使用InheritableThreadLocal了. 首先我们来看一下InheritableThreadLocal的jdk源码: package java.lang; import java.lang.ref.*; public class InheritableThreadLocal<T> extends ThreadLocal<T> { p

java中ThreadLocalRandom的使用详解

在java中我们通常会需要使用到java.util.Random来便利的生产随机数.但是Random是线程安全的,如果要在线程环境中的话就有可能产生性能瓶颈. 我们以Random中常用的nextInt方法为例来具体看一下: public int nextInt() { return next(32); } nextInt方法实际上调用了下面的方法: protected int next(int bits) { long oldseed, nextseed; AtomicLong seed = t

快速了解Java中ThreadLocal类

最近看Android FrameWork层代码,看到了ThreadLocal这个类,有点儿陌生,就翻了各种相关博客一一拜读:自己随后又研究了一遍源码,发现自己的理解较之前阅读的博文有不同之处,所以决定自己写篇文章说说自己的理解,希望可以起到以下作用: - 可以疏通研究结果,加深自己的理解: - 可以起到抛砖引玉的作用,帮助感兴趣的同学疏通思路: - 分享学习经历,同大家一起交流和学习. 一. ThreadLocal 是什么 ThreadLocal 是Java类库的基础类,在包java.lang下

java中ThreadLocal取不到值的两种原因

1.两种原因 第一种,也是最常见的一种,就是多个线程使用ThreadLocal 第二种,类加载器不同造成取不到值,本质原因就是不同类加载器造成多个ThreadLocal对象 public class StaticClassLoaderTest { protected static final ThreadLocal<Object> local = new ThreadLocal<Object>(); //cusLoader加载器加载的对象 private Test3 test3;

Java ThreadLocal用法实例详解

本文实例讲述了Java ThreadLocal用法.分享给大家供大家参考,具体如下: 目录 ThreadLocal的基本使用 ThreadLocal实现原理 源码分析(基于openjdk11) get方法: setInitialValue方法 getEntry方法 set方法 ThreadLocalMap的set方法 replaceStaleEntry方法 cleanSomeSlots方法 rehash方法 expungeStaleEntries方法 resize方法 ThreadLocal实现

Java List 用法实例详解

Java List 用法实例详解 Java中可变数组的原理就是不断的创建新的数组,将原数组加到新的数组中,下文对Java List用法做了详解. List:元素是有序的(怎么存的就怎么取出来,顺序不会乱),元素可以重复(角标1上有个3,角标2上也可以有个3)因为该集合体系有索引 ArrayList:底层的数据结构使用的是数组结构(数组长度是可变的百分之五十延长)(特点是查询很快,但增删较慢)线程不同步 LinkedList:底层的数据结构是链表结构(特点是查询较慢,增删较快) Vector:底层

java return用法实例详解

return用法总结: 一.在有返回值的方法中,返回方法指定类型的值,同时结束方法执行: 二.也可以用在返回值为void的方法中,用来终止方法运行: break和return break是用来跳出循环的,例如for,while,do-while都可以跳出,但不跳出函数 return是使整个函数返回的,后面的不管是循环里面还是循环外面的都不执行 1.可以在具有对象引用返回类型的方法中返回null public Button doStuff(){ return null: } 2.数组是完全合法的返

Java中的instanceof关键字在Android中的用法实例详解

在下面介绍Android中如何使用instanceof关键字开发更方便时,先来温习一下java中instanceof的概念. instanceof大部分的概念是这样定义的:instanceof是Java的一个二元操作符,和==,>,<是同一类东西.由于它是由字母组成的,所以也是Java的保留关键字.它的作用是测试它左边的对象是否是它右边的类的实例,返回boolean类型的数据.举个栗子: String s = "I AM an Object!"; boolean isObj

java中静态导入机制用法实例详解

java中静态导入机制用法实例详解 这里主要讲解了如何使用Java中静态机制的用法,这里提供了简单实例大家可以参考下. 静态常量类 在java开发中,我们会经常用到一些静态常量用于状态判断等操作.为了能够在多个地方复用这些常量,通常每个模块都会加一个常量类,举个简单的列子: import com.sky.OrderMouleConsstants; /** * Created by gantianxing on 2017/4/21. */ public class Test { public vo

Java设计模式之策略模式原理与用法实例详解

本文实例讲述了Java设计模式之策略模式原理与用法.分享给大家供大家参考,具体如下: 策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换.策略模式让算法独立于使用它的客户而独立变化.其中JDK里面的TreeSet类和TreeMap类就用到了策略模式.这两个类是带排序的集合类,其中排序的规则就相当于策略模式里定义的一系列算法,而集合类就相当于是策略模式里的环境类,供用户使用,用只知道TreeSet和TreeMap是带排序的,至于怎么排序的,是由排序的算法决定的. 策略模式

Java设计模式之装饰模式原理与用法实例详解

本文实例讲述了Java设计模式之装饰模式原理与用法.分享给大家供大家参考,具体如下: 装饰模式能在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能.它是通过创建一个包装对象,也就是装饰来包裹真实的对象.JDK中IO的设计就用到了装饰模式,通过过滤流对节点流进行包装来实现功能的扩展. 装饰模式的角色的组成: ① 抽象构件(Component)角色:给出一个抽象接口,以规范准备接收附加工功能的对象.(InputStream.OutputStream) ② 具体构件(Concrete Co

java 抽象类的实例详解

java 抽象类的实例详解 前言: 什么是抽象类?这名字听着就挺抽象的,第一次听到这个名字还真有可能被唬住.但是,就像老人家所说的,一切反动派都是纸老虎,一切有着装x名字的概念也是纸老虎.好吧,我们已经从战略上做到了藐视它,现在就要战术上重视它,如同要解决纸老虎,就要一个牙齿一个牙齿地敲,一个爪子一个爪子地拔:解决这种抽象概念也一样,先要把它具体化,细分化,然后一个一个地来. 我一般遇到新的概念都会问三个问题: 1.这个东西有什么用?用来干什么的?它的意义在哪里?(显然,如果是没用的东西,就没必

MyBatis动态SQL标签用法实例详解

1.动态SQL片段 通过SQL片段达到代码复用 <!-- 动态条件分页查询 --> <sql id="sql_count"> select count(*) </sql> <sql id="sql_select"> select * </sql> <sql id="sql_where"> from icp <dynamic prepend="where&quo

Angular中$cacheFactory的作用和用法实例详解

先说下缓存: 一个缓存就是一个组件,它可以透明地储存数据,以便以后可以更快地服务于请求.多次重复地获取资源可能会导致数据重复,消耗时间.因此缓存适用于变化性不大的一些数据,缓存能够服务的请求越多,整体系统性能就能提升越多. $cacheFactory介绍: $cacheFactory是一个为Angular服务生产缓存对象的服务.要创建一个缓存对象,可以使用$cacheFactory通过一个ID和capacity.其中,ID是一个缓存对象的名称,capacity则是描述缓存键值对的最大数量. 1.