您当前的位置:首页 > 电脑百科 > 程序开发 > 编程百科

ThreadLocal原理及使用场景大揭秘

时间:2021-01-14 10:13:05  来源:  作者:

是什么

ThreadLocal从名字上看好像是一个Thread,其实并不是,它是Therad的局部变量的维护类。作用是让变量私有化(为每个Thread提供变量的副本),以此来实现线程间变量的隔离。比如有一个变量count,在多线程并发时操作count++会出现线程安全问题。但是通过ThreadLocal count,就可以为每个线程创建只属于当前线程的count副本,各自操作各自的副本,不会影响到其他线程。我们先有个概念,具体还是看源码(JDK1.8)。

ThreadLocal原理及使用场景大揭秘

 

原理源码

简单用法

public static void main(String[] args) {
        ThreadLocal<String> a = new ThreadLocal<String>();
        a.set("1");
        a.set("2");
        System.out.println(a.get());
    }
//输出结果是2。貌似“1”被覆盖了。

先看一下set(T value)方法。

  /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     *
     */
    public void set(T value) {
        //当前线程
        Thread t = Thread.currentThread();
        //获取ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        //map为空就创建,不为空就set
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
     //给t.threadLocals赋值成ThreadLocalMap实例。
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
   }
   /**
   * Set the resize threshold to maintain at worst a 2/3 load factor.
   */
   private void setThreshold(int len) {
       threshold = len * 2 / 3;
   }
   
   /* 当前线程对于的ThreadLocalMap实例,在ThreadL类中*/
   ThreadLocal.ThreadLocalMap threadLocals = null;

这段代码逻辑比较简单,主要看ThreadLocalMap,它是TreadLocal的内部类,虽然没有实现Map接口,但看它的几个主要属性:Entry[] table、size、threshold、INITIAL_CAPACITY,和JAVA.util.HashMap极其类似。关于这些属性更详尽的解释可以看一下这篇深入讲解HashMap的工作原理 。class注释中也提到它是一个为存放本地线程值而定制的hash map。它的key就是ThreadLocal当前实例this,值就是set的参数值。既然是hash map,就有可能出现hash冲突的问题,再复习一下解决hash冲突的常见方法

  1. 再哈希法:如果hash出的index已经有值,就再hash,不行继续hash,直至找到空的index位置。
  2. **开放地址法:**如果hash出的index已经有值,通过算法在它前面或后面的若干位置寻找空位。
  3. 建立公共溢出区: 把冲突的hash值放到另外一块溢出区。
  4. 链式地址法: 把产生hash冲突的hash值以链表形式存储在index位置上。HashMap的解决方案。

ThreadLocalMap用的是开放地址方法,如果当前位置有值,就继续寻找下一个位置,注意table[len-1]的下一个位置是table[0],就像是一个环形数组,所以也叫闭散列法。如果一直都找不到空位置就会出现死循环,发生内存溢出。当然有扩容机制,一般不会找不到空位置的。

/**
* ThreadLocalMap is a customized hash map suitable only for
* maintaining thread local values. No operations are exported
* outside of the ThreadLocal class. The class is package private to
* allow declaration of fields in class Thread.  To help deal with
* very large and long-lived usages, the hash table entries use
* WeakReferences for keys. However, since reference queues are not
* used, stale entries are guaranteed to be removed only when
* the table starts running out of space.
* 
*/
static class ThreadLocalMap {
    
   static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
      Entry(ThreadLocal<?> k, Object v) {
          super(k);
          value = v;
        }
   }
   
  /**
   * The table, resized as necessary.
   * table.length MUST always be a power of two.
   * table.length必须是2的幂次
   */
   private Entry[] table;

  /**
   * The number of entries in the table.
   * table实际已经存放#Entry的数量
  */
    private int size = 0;

   /**
    * The next size value at which to resize.
    * table扩容的阈值,初始threshold = length * 2 / 3,当size>threshold*3/4时就扩容
    */
    private int threshold;
  
    /**
    * The initial capacity -- MUST be a power of two.
    * table 的默认容量
    */
    private static final int INITIAL_CAPACITY = 16;
   
   /**
    * 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) {
            Entry[] tab = table;
            int len = tab.length;
            //计算key的角标index。就是用key的threadLocalHashCode & (len-1)等效于key.threadLocalHashCode%len
            //只是&要比%效率高,它们之所以可以等效,因为len是2的n次幂。
            //threadLocalHashCode并不影响读懂这块代码,放在后面详说
            int i = key.threadLocalHashCode & (len-1);
            //开放地址方法,循环tab
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                //key相同,更新value
                if (k == key) {
                    e.value = value;
                    return;
                }
                //key为空,说明ThreadLocal实例被回收了,用新key-value替代
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            //table[i]=null 新建一个Entity,++size
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
    //整理table
   private void rehash() {
      //删除table[]陈旧元素
      expungeStaleEntries();
      //size依然大于3/4 threshold,扩容
      if (size >= threshold - threshold / 4)
          resize();
    }
/**
 * Expunge all stale entries in the table.
 * 删除table[]所有key==null的entity
*/
  private void expungeStaleEntries() {
    Entry[] tab = table;
     int len = tab.length;
      for (int j = 0; j < len; j++) {
       Entry e = tab[j];
        if (e != null && e.get() == null)
           expungeStaleEntry(j);
        }
  }
   
   /**
     * Double the capacity of the table.
     * 扩容为原数组的2倍
    */
   private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2;
            //创建2倍容量的新数组
            Entry[] newTab = new Entry[newLen];
            int count = 0;

            for (int j = 0; j < oldLen; ++j) {
                Entry e = oldTab[j];
                if (e != null) {
                    //如果线程的
                    ThreadLocal<?> k = e.get();
                    if (k == null) {
                        e.value = null; // Help the GC
                    } else { 
                        //计算新数组index
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
   }
   //返回当前线程对应的ThreadLocalMap
   ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
   }
}

看了set方法,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;
            }
        }
    return setInitialValue();
}
/**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
  */
private T setInitialValue() {
   T value = initialValue();//null
   Thread t = Thread.currentThread();
   ThreadLocalMap map = getMap(t);
   if (map != null)
        map.set(this, value);
   else
       createMap(t, value);
        return value;
 }
//默认值null
protected T initialValue() {
  return null;
}

源码总结:

总体来讲,ThreadLocal源码比较好理解。ThreadLocalMap虽然在ThreadLocal中定义,但是被Thread.threadLocals引用。这样保证了一个Thread拥有独立的ThreadLocalMap,做到和其他线程隔离。而ThreadLocalMap的key就是ThreadLocal实例,value就是线程变量。

再看一下最开始的源码。

public static void main(String[] args) {
        ThreadLocal<String> a =new ThreadLocal<String>();
        a.set("1");
        a.set("2");
        System.out.println(a.get());
    }
//输出结果是2。貌似“1”被覆盖了。
//确实是被覆盖了,Thread.threadLocals的key是a,值当然只能有一个,get到的值也是最后一个value
//单线程的内部实现类似这样
   ThreadLocal<String> a =new ThreadLocal<String>();
   Map map = new HashMap();
   map.put(a,"1");
   map.put(a,"2");
   System.out.println(map.get(a));

源码中的问题总结

  1. ThreadLocalMap的hash冲突问题

上文说到ThreadLocalMap解决hash冲突的方法是开放地址。但对threadLocalHashCode没有详细说明,下面补充说明一下它。

//计算数组下标
int i = key.threadLocalHashCode & (len-1);

private final int threadLocalHashCode = nextHashCode();
/**
* The next hash code to be given out. Updated atomically. Starts at
* zero.
* 线程安全的原子类,发出下一个hash code
*/
private static AtomicInteger nextHashCode = new AtomicInteger();
/**
* getAndAdd(v)返回的结果是nextHashCode,但是nextHashCode+=HASH_INCREMENT;
*/
private static int nextHashCode() {
  return nextHashCode.getAndAdd(HASH_INCREMENT);
}

/**
* The difference between successively generated hash codes - turns
* implicit sequential thread-local IDs into near-optimally spread
* multiplicative hash values for power-of-two-sized tables.
* 自增量
*/
private static final int HASH_INCREMENT = 0x61c88647;

因为nextHashCode被static修饰,所以每次new ThreadLocal()都会自增HASH_INCREMENT,其值和斐波那契散列(Fibonacci)有关,主要目的是为了让哈希码能均匀的分布在2的n次方的数组里。这也是为什么table的容量是2的n次方的一个原因。

  1. 内存泄漏 & 弱引用 ThreadLocal使用不当可能会出现内存泄露,进而可能导致内存溢出**, 内存泄露:垃圾对象没有及时回收或无法回收,一般情况下是因为对象有错误的引用,导致内存浪费,这些垃圾越来越多可能会导致内存溢出内存溢出:没有足够的内存提供申请者使用。 当然了,任何操作不当都会出现内存泄露或其他bug,我们这里只谈论ThreadLocal。 回顾Thread、ThreadLocal、ThreadLocalMap的关系。 Thread.threadLocals引用ThreadLocalMap,生命周期一致。ThreadLocal定义ThreadLocalMapThreadLocalMap#Entry弱引用ThreadLocal。我们通常说一个对象不被引用就会被gc回收,其实说的是强引用。但弱引用对象是,不管有没有被引用都会被垃圾回收。 当一个Thread执行完,被销毁后,Thread.threadLocals指向的ThreadLocalMap实例也会随之变为垃圾,当然它里面存放的Entity也会被回收。这时是不会发生内存泄漏的。 发生内存泄漏一般是在线程池,Thread生命周期比较长,threadLocals引用一直存在,当其存放的ThreadLocal被回收(弱引用生命周期比较短)后,它对应的Entity就成了key==null的实例,依然不会被回收。如果此Entity一直不被get()、set()、remove()它就一直不会被回收,也就发生了内存泄漏。通常在使用完ThreadLocal都会调用它的remove()。 补充:在ThreadLocal的get、set的时候,都会检查当前Entity的key是否为null,如果是null就把Entity释放掉,被垃圾回收。

应用场景

它的应用场景主要有

  1. 线程安全,包裹线程不安全的工具类,比如java.text.SimpleDateFormat类,当然jdk1.8已经给出了对应的线程安全的类java.time.format.DateTimeFormatter
  2. 线程隔离,比如数据库连接管理、Session管理、mdc日志追踪等。

最近在与前端对接的接口中用到了ThreadLocal。大概流程是,前端在请求后端接口时在header带上toekn,拦截器通过token获取到用户信息,通过ThreadLocal保存。主要代码如下:

//接口请求时先走filter
public boolean checkUserLogin(String token){
   UserDTO user = getUserByToken(token);
   ContextUtil.setUserId(user.getId());
}

public class ContextUtil {
    private static ThreadLocal<String> userIdHolder = new ThreadLocal();
    //存储userid
    public static void setUserId(String userId) {
        userIdHolder.set(userId);
    }
    
    public static String getUserId() {
        return (String)userIdHolder.get();
    }
}    

//实际调用接口
void invokeInterface(){
   String userId = ContextUtil.getUserId();
   .....
}

每一次接口请求都是一个线程,在校验接口合法后把userid存入ThreadLocal,以备后续之用。

总结

我们通过源码,对ThreadLocal的原理和应用作了深入讲解。当然本人能力一般,水平有限,难免有些谬误。还请各位多担待,欢迎指正。有反馈才有进步。



Tags:ThreadLocal   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除,谢谢。
▌相关推荐
前言上次有个小伙伴问我,说他面试的时候,被问到ThreadLocal内存溢出问题,没有回答出来;那我们今天就来了解一下ThreadLocal。ThreadLocal介绍多线程在访问同一个变量时会产生线...【详细内容】
2021-06-17  Tags: ThreadLocal  点击:(161)  评论:(0)  加入收藏
是什么ThreadLocal从名字上看好像是一个Thread,其实并不是,它是Therad的局部变量的维护类。作用是让变量私有化(为每个Thread提供变量的副本),以此来实现线程间变量的隔离。比如...【详细内容】
2021-01-14  Tags: ThreadLocal  点击:(188)  评论:(0)  加入收藏
当多线程访问共享可变数据时,涉及到线程间同步的问题,并不是所有时候,都要用到共享数据,所以就需要线程封闭出场了。数据都被封闭在各自的线程之中,就不需要同步,这种通过将数据封...【详细内容】
2020-07-29  Tags: ThreadLocal  点击:(44)  评论:(0)  加入收藏
闲谈ThreadLocal前面在我的GitHub仓库 V-LoggingTool 中有简单的使用过ThreadLocal,主要用在了切面类中,功能上需要取到前置增强拦截到的用户信息暂存,执行到后置增强时从该Thr...【详细内容】
2020-07-05  Tags: ThreadLocal  点击:(57)  评论:(0)  加入收藏
FastThreadLocal 作用与JDK 原生的ThreadLocal功能是一样的,FastThreadLocal 持有指定类的对象,可以保证每个线程都持有一个唯一实例,每个线程持有实例都只在本线程内使用,所以不会有并发问题。但它的访问速度更快,顾名思...【详细内容】
2019-08-28  Tags: ThreadLocal  点击:(314)  评论:(0)  加入收藏
▌简易百科推荐
摘 要 (OF作品展示)OF之前介绍了用python实现数据可视化、数据分析及一些小项目,但基本都是后端的知识。想要做一个好看的可视化大屏,我们还要学一些前端的知识(vue),网上有很多比...【详细内容】
2021-12-27  项目与数据管理    Tags:Vue   点击:(1)  评论:(0)  加入收藏
程序是如何被执行的&emsp;&emsp;程序是如何被执行的?许多开发者可能也没法回答这个问题,大多数人更注重的是如何编写程序,却不会太注意编写好的程序是如何被运行,这并不是一个好...【详细内容】
2021-12-23  IT学习日记    Tags:程序   点击:(9)  评论:(0)  加入收藏
阅读收获✔️1. 了解单点登录实现原理✔️2. 掌握快速使用xxl-sso接入单点登录功能一、早期的多系统登录解决方案 单系统登录解决方案的核心是cookie,cookie携带会话id在浏览器...【详细内容】
2021-12-23  程序yuan    Tags:单点登录(   点击:(8)  评论:(0)  加入收藏
下载Eclipse RCP IDE如果你电脑上还没有安装Eclipse,那么请到这里下载对应版本的软件进行安装。具体的安装步骤就不在这赘述了。创建第一个标准Eclipse RCP应用(总共分为六步)1...【详细内容】
2021-12-22  阿福ChrisYuan    Tags:RCP应用   点击:(7)  评论:(0)  加入收藏
今天想简单聊一聊 Token 的 Value Capture,就是币的价值问题。首先说明啊,这个话题包含的内容非常之光,Token 的经济学设计也可以包含诸多问题,所以几乎不可能把这个问题说的清...【详细内容】
2021-12-21  唐少华TSH    Tags:Token   点击:(9)  评论:(0)  加入收藏
实现效果:假如有10条数据,分组展示,默认在当前页面展示4个,点击换一批,从第5个开始继续展示,到最后一组,再重新返回到第一组 data() { return { qList: [], //处理后...【详细内容】
2021-12-17  Mason程    Tags:VUE   点击:(14)  评论:(0)  加入收藏
什么是性能调优?(what) 为什么需要性能调优?(why) 什么时候需要性能调优?(when) 什么地方需要性能调优?(where) 什么时候来进行性能调优?(who) 怎么样进行性能调优?(How) 硬件配...【详细内容】
2021-12-16  软件测试小p    Tags:性能调优   点击:(19)  评论:(0)  加入收藏
Tasker 是一款适用于 Android 设备的高级自动化应用,它可以通过脚本让重复性的操作自动运行,提高效率。 不知道从哪里听说的抖音 app 会导致 OLED 屏幕烧屏。于是就现学现卖,自...【详细内容】
2021-12-15  ITBang    Tags:抖音防烧屏   点击:(23)  评论:(0)  加入收藏
11 月 23 日,Rust Moderation Team(审核团队)在 GitHub 上发布了辞职公告,即刻生效。根据公告,审核团队集体辞职是为了抗议 Rust 核心团队(Core team)在执行社区行为准则和标准上...【详细内容】
2021-12-15  InfoQ    Tags:Rust   点击:(24)  评论:(0)  加入收藏
一个项目的大部分API,测试用例在参数和参数值等信息会有很多相似的地方。我们可以复制API,复制用例来快速生成,然后做细微调整既可以满足我们的测试需求1.复制API:在菜单发布单...【详细内容】
2021-12-14  AutoMeter    Tags:AutoMeter   点击:(20)  评论:(0)  加入收藏
最新更新
栏目热门
栏目头条