ThreadLocal

基本使用

ThreadLocal 的作用是:提供线程内的局部变量,不同的线程之间不会相互干扰,这种变量在线程的生命周期内起作用,减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度,降低耦合性。

方法声明 描述
ThreadLocal() 创建ThreadLocal对象
public void set( T value) 设置当前线程绑定的局部变量
public T get() 获取当前线程绑定的局部变量
public void remove() 移除当前线程绑定的局部变量

简单使用:

public class MyDemo {
private String content; private String getContent() {
return content;
} private void setContent(String content) {
this.content = content;
} public static void main(String[] args) {
MyDemo demo = new MyDemo();
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
demo.setContent(Thread.currentThread().getName() + "的数据");
System.out.println("-----------------------");
System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
}
});
thread.setName("线程" + i);
thread.start();
}
}
}

public class MyDemo {

    private static ThreadLocal<String> tl = new ThreadLocal<>();

    private String content;

    private String getContent() {
return tl.get();
} private void setContent(String content) {
tl.set(content);
} public static void main(String[] args) {
MyDemo demo = new MyDemo();
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
demo.setContent(Thread.currentThread().getName() + "的数据");
System.out.println("-----------------------");
System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
}
});
thread.setName("线程" + i);
thread.start();
}
}
}

这样可以很好的解决多线程之间数据隔离的问题,用synchronized加锁也可以实现,但synchronized侧重的是多个线程之间访问资源的同步性,而ThreadLocal侧重的是每个线程之间的数据隔离。

synchronized ThreadLocal
原理 同步机制采用'以时间换空间'的方式, 只提供了一份变量,让不同的线程排队访问 ThreadLocal采用'以空间换时间'的方式, 为每一个线程都提供了一份变量的副本,从而实现同时访问而相不干扰
侧重点 多个线程之间访问资源的同步性 多线程中让每个线程之间的数据相互隔离

应用场景

涉及到数据传递线程隔离的场景,可以考虑用ThreadLocal来解决:转账案例,涉及两个DML操作: 一个转出,一个转入。这些操作是需要具备原子性的。所以这里就需要操作事务,来保证转出和转入操作具备原子性。开启事务的注意两点:

  • 为了保证所有的操作在一个事务中, 使用的连接必须是同一个: service层开启事务的connection需要跟dao层访问数据库的connection保持一致。
  • 线程并发情况下, 每个线程只能操作各自的 connection。

用ThreadLocal的解决方案:在获取Connection连接的JdbcUtils工具类加入ThreadLocal,代码如下:

public class JdbcUtils {
//ThreadLocal对象 : 将connection绑定在当前线程中
private static final ThreadLocal<Connection> tl = new ThreadLocal(); // c3p0 数据库连接池对象属性
private static final ComboPooledDataSource ds = new ComboPooledDataSource(); // 获取连接
public static Connection getConnection() throws SQLException {
//取出当前线程绑定的connection对象
Connection conn = tl.get();
if (conn == null) {
//如果没有,则从连接池中取出
conn = ds.getConnection();
//再将connection对象绑定到当前线程中
tl.set(conn);
}
return conn;
} //释放资源
public static void release(AutoCloseable... ios) {
for (AutoCloseable io : ios) {
if (io != null) {
try {
io.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
} public static void commitAndClose() {
try {
Connection conn = getConnection();
//提交事务
conn.commit();
//解除绑定
tl.remove();
//释放连接
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
} public static void rollbackAndClose() {
try {
Connection conn = getConnection();
//回滚事务
conn.rollback();
//解除绑定
tl.remove();
//释放连接
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

可以看出使用ThreadLocal的好处:

  1. 传递数据 : 保存每个线程绑定的数据,在需要的地方可以直接获取, 避免参数直接传递带来的代码耦合问题
  2. 线程隔离 : 各线程之间的数据相互隔离却又具备并发性,避免同步方式带来的性能损失

ThreadLocal的内部结构

jdk8以前:

jdk8之前使用ThreadLocal来维护一个ThreadLocalMap,以线程作为key

jdk8以后:

jdk8之后使用Thread来维护一个ThreadLocalMap,以ThreadLocal作为key

这样涉及的好处:

(1) 每个Map存储的Entry数量就会变少,因为jdk8之前的存储数量由Thread的数量决定,现在是由ThreadLocal的数量决定。

(2) 当Thread销毁之后,对应的ThreadLocalMap也会随之销毁,能减少内存的使用。

ThreadLocal核心方法的源码

方法声明 描述
protected T initialValue() 返回当前线程局部变量的初始值
public void set( T value) 设置当前线程绑定的局部变量
public T get() 获取当前线程绑定的局部变量
public void remove() 移除当前线程绑定的局部变量

get()

/**
* 返回当前线程中保存ThreadLocal的值
* 如果当前线程没有此ThreadLocal变量,
* 则它会通过调用{@link #initialValue} 方法进行初始化值
*
* @return 返回当前线程对应此ThreadLocal的值
*/
public T get() {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null) {
// 以当前的ThreadLocal 为 key,调用getEntry获取对应的存储实体e
ThreadLocalMap.Entry e = map.getEntry(this);
// 找到对应的存储实体 e
if (e != null) {
@SuppressWarnings("unchecked")
// 获取存储实体 e 对应的 value值
// 即为我们想要的当前线程对应此ThreadLocal的值
T result = (T)e.value;
return result;
}
}
// 如果map不存在,则证明此线程没有维护的ThreadLocalMap对象
// 调用setInitialValue进行初始化
return setInitialValue();
} /**
* set的变样实现,用于初始化值initialValue,
* 用于代替防止用户重写set()方法
*
* @return the initial value 初始化后的值
*/
private T setInitialValue() {
// 调用initialValue获取初始化的值
T value = initialValue();
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null)
// 存在则调用map.set设置此实体entry
map.set(this, value);
else
// 1)当前线程Thread 不存在ThreadLocalMap对象
// 2)则调用createMap进行ThreadLocalMap对象的初始化
// 3)并将此实体entry作为第一个值存放至ThreadLocalMap中
createMap(t, value);
// 返回设置的值value
return value;
} /**
* 获取当前线程Thread对应维护的ThreadLocalMap
*
* @param t the current thread 当前线程
* @return the map 对应维护的ThreadLocalMap
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
/**
*创建当前线程Thread对应维护的ThreadLocalMap
*
* @param t 当前线程
* @param firstValue 存放到map中第一个entry的值
*/
void createMap(Thread t, T firstValue) {
//这里的this是调用此方法的threadLocal
t.threadLocals = new ThreadLocalMap(this, firstValue);
}

首先调用Thread.currentThread()方法获取当前线程对象,然后根据当前线程获取维护的ThreadLocalMap对象;如果获取的Map不为空,则在Map中以ThreadLocal的引用作为key,调用getEntry获取对应的存储实体,如果Entry不为空,获取对应的 value值。如果Map为空或者Entry为空,则调用setInitialValue()方法。setInitialValue()方法里,调用initialValue()方法获取初始化值value,然后判断当前线程是否有ThreadLocalMap,map存在,调用set设置Entry;map不存在则调用createMap()进行ThreadLocalMap对象的初始化,并将此entry作为第一个值存放至ThreadLocalMap中。

set()

/**
* 设置当前线程对应的ThreadLocal的值
*
* @param value 将要保存在当前线程对应的ThreadLocal的值
*/
public void set(T value) {
// 获取当前线程对象
Thread t = Thread.currentThread();
// 获取此线程对象中维护的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null)
// 存在则调用map.set设置此实体entry
map.set(this, value);
else
// 1)当前线程Thread 不存在ThreadLocalMap对象
// 2)则调用createMap进行ThreadLocalMap对象的初始化
// 3)并将此实体entry作为第一个值存放至ThreadLocalMap中
createMap(t, value);
}

​ A. 首先获取当前线程,并根据当前线程获取一个ThreadLocalMap

​ B. 如果获取的Map不为空,则将参数设置到Map中(当前ThreadLocal的引用作为key)

​ C. 如果Map为空,则调用createMap给该线程创建 Map,并设置初始值

remove()

/**
* 删除当前线程中保存的ThreadLocal对应的实体entry
*/
public void remove() {
// 获取当前线程对象中维护的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null)
// 存在则调用map.remove
// 以当前ThreadLocal为key删除对应的实体entry
m.remove(this);
}

A. 首先获取当前线程,并根据当前线程获取一个ThreadLocalMap

B. 如果获取的Map不为空,则移除当前ThreadLocal对象对应的entry

initialValue()

protected T initialValue() {
return null;
}

(1) 这个方法是一个延迟调用方法,在set方法还未调用而先调用了get方法时才执行,并且仅执行1次。

(2)这个方法直接返回一个null

(3)如果想要一个除null之外的初始值,可以重写此方法。(备注: 该方法是一个protected的方法,显然是为了让子类覆盖而设计的)

ThreadLocalMap

ThreadLocalMap是ThreadLocal的内部类,没有实现Map接口,用独立的方式实现了Map的功能,其内部的Entry也是独立实现。

  1. 成员变量

    /**
    * 初始容量 —— 必须是2的整次幂
    */
    private static final int INITIAL_CAPACITY = 16; /**
    * 存放数据的table
    * 同样,数组长度必须是2的幂。
    */
    private Entry[] table; /**
    * 数组里面entrys的个数,可以用于判断table当前使用量是否超过负载因子。
    */
    private int size = 0; /**
    * 进行扩容的阈值,表使用量大于它的时候进行扩容。
    */
    private int threshold; // Default to 0 /**
    * 阈值设置为长度的2/3
    */
    private void setThreshold(int len) {
    threshold = len * 2 / 3;
    }
  2. Entry

    static class Entry extends WeakReference<ThreadLocal> {
    /** The value associated with this ThreadLocal. */
    Object value; Entry(ThreadLocal k, Object v) {
    super(k);
    value = v;
    }
    }

    在ThreadLocalMap中,也是用Entry来保存K-V结构数据的。但是Entry中key只能是ThreadLocal对象,这点被Entry的构造方法已经限定死了;

    另外,Entry继承WeakReference,使用弱引用,可以将ThreadLocal对象的生命周期和线程生命周期解绑,持有对ThreadLocal的弱引用,可以使得ThreadLocal在没有其他强引用的时候被回收掉,这样可以避免因为线程得不到销毁导致ThreadLocal对象无法被回收

  3. hash冲突的解决

    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    //初始化table
    table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY]; //16
    //计算索引
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //设置值
    table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
    size = 1;
    //设置阈值
    setThreshold(INITIAL_CAPACITY);
    }
    • & (INITIAL_CAPACITY - 1),这是取模的一种方式,对于2的幂取模,用此代替%(2^n),这也就是为啥容量必须为2的幂

    • firstKey.threadLocalHashCode

      private final int threadLocalHashCode = nextHashCode();
      
      private static int nextHashCode() {
      return nextHashCode.getAndAdd(HASH_INCREMENT);
      }
      private static AtomicInteger nextHashCode = new AtomicInteger(); private static final int HASH_INCREMENT = 0x61c88647;

      这里定义了一个AtomicInteger类型,每次获取当前值并加上HASH_INCREMENT,HASH_INCREMENT = 0x61c88647,这个值是32位整型上限2^32-1乘以黄金分割比例0.618....的值2654435769,用有符号整型表示就是-1640531527,去掉符号后16进制表示为0x61c88647,目的就是为了让哈希码能均匀的分布在2的n次方的数组Entry[] table中。

    • 线性探测法:

      该方法一次探测下一个地址,直到有空的地址后插入,若整个空间都找不到空余的地址,则产生溢出。假设当前table长度为16,也就是说如果计算出来key的hash值为14,如果table[14]上已经有值,并且其key与当前key不一致,那么就发生了hash冲突,这个时候将14加1得到15,取table[15]进行判断,这个时候如果还是冲突会回到0,取table[0],以此类推,直到可以插入。可以把table看成一个环形数组

       /**
      * 获取环形数组的下一个索引
      */
      private static int nextIndex(int i, int len) {
      return ((i + 1 < len) ? i + 1 : 0);
      } /**
      * 获取环形数组的上一个索引
      */
      private static int prevIndex(int i, int len) {
      return ((i - 1 >= 0) ? i - 1 : len - 1);
      }
    • ThreadLocalMap的set():

      private void set(ThreadLocal<?> key, Object value) {
      ThreadLocal.ThreadLocalMap.Entry[] tab = table;
      int len = tab.length;
      //计算索引
      int i = key.threadLocalHashCode & (len-1);
      /**
      * 根据获取到的索引进行循环,如果当前索引上的table[i]不为空,在没有return的情况下,
      * 就使用nextIndex()获取下一个(线性探测法)。
      */
      for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
      e != null;
      e = tab[i = nextIndex(i, len)]) {
      ThreadLocal<?> k = e.get();
      //table[i]上key不为空,并且和当前key相同,更新value
      if (k == key) {
      e.value = value;
      return;
      }
      /**
      * table[i]上的key为空,说明被回收了
      * 这个时候table[i]可以重新使用,用新的key-value将其替换,并删除其他无效的entry
      */
      if (k == null) {
      replaceStaleEntry(key, value, i);
      return;
      }
      }

ThreadLocal应用及源码分析的更多相关文章

  1. ThreadLocal 简介 案例 源码分析 MD

    Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱 MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina ...

  2. ThreadLocal和ThreadLocalMap源码分析

    目录 ThreadLocal和ThreadLocalMap源码分析 背景分析 定义 例子 源码分析 ThreadLocalMap源码分析 ThreadLocal源码分析 执行流程总结 源码分析总结 T ...

  3. ThreadLocal介绍以及源码分析

    ThreadLocal 线程主变量 前面部分引用其他优秀博客,后面源码自己分析的,如有冒犯请私聊我. 用Java语言开发的同学对 ThreadLocal 应该都不会陌生,这个类的使用场景很多,特别是在 ...

  4. ThreadLocal与ThreadLocalMap源码分析

    ThreadLocal类 该类主要用于不同线程存储自己的线程本地变量.本文先通过一个示例简单介绍该类的使用方法,然后从ThreadLocal类的初始化.存储结构.增删数据和hash值计算等几个方面,分 ...

  5. 并发编程(四)—— ThreadLocal源码分析及内存泄露预防

    今天我们一起探讨下ThreadLocal的实现原理和源码分析.首先,本文先谈一下对ThreadLocal的理解,然后根据ThreadLocal类的源码分析了其实现原理和使用需要注意的地方,最后给出了两 ...

  6. 并发-ThreadLocal源码分析

    ThreadLocal源码分析 参考: http://www.cnblogs.com/dolphin0520/p/3920407.html https://www.cnblogs.com/coshah ...

  7. 并发编程(四):ThreadLocal从源码分析总结到内存泄漏

    一.目录      1.ThreadLocal是什么?有什么用?      2.ThreadLocal源码简要总结?      3.ThreadLocal为什么会导致内存泄漏? 二.ThreadLoc ...

  8. Java多线程学习之ThreadLocal源码分析

    0.概述 ThreadLocal,即线程本地变量,是一个以ThreadLocal对象为键.任意对象为值的存储结构.它可以将变量绑定到特定的线程上,使每个线程都拥有改变量的一个拷贝,各线程相同变量间互不 ...

  9. Java并发编程之ThreadLocal源码分析

    ## 1 一句话概括ThreadLocal<font face="微软雅黑" size=4>  什么是ThreadLocal?顾名思义:线程本地变量,它为每个使用该对象 ...

随机推荐

  1. 单调队列+线性dp题Watching Fireworks is Fun (CF372C)

    一.Watching Fireworks is Fun(紫题) 题目:一个城镇有n个区域,从左到右1编号为n,每个区域之间距离1个单位距离节日中有m个烟火要放,给定放的地点ai,时间ti当时你在x,那 ...

  2. 2019-2020-1 20209313《Linux内核原理与分析》第二周作业

    2019-2020-1 20209313<Linux内核原理与分析>第二周作业 零.总结 阐明自己对"计算机是如何工作的"理解. 一.myod 步骤 复习c文件处理内容 ...

  3. 选择SaaS平台的那些事

    将近一年多没有更新博客和自己的订阅号.除了本身有点懒之外,也有幸在上半年花了一些时间考出了CISSP.最近也在研究云平台相关的一些课题. 写这篇文章本身是因为在工作中经常有IT乃至业务的同事会问及企业 ...

  4. JAVA递归实现线索化二叉树

    JAVA递归实现线索化二叉树 基础理论 首先,二叉树递归遍历分为先序遍历.中序遍历和后序遍历. 先序遍历为:根节点+左子树+右子树 中序遍历为:左子树+根节点+右子树 后序遍历为:左子树+右子树+根节 ...

  5. 用node.js给C#写一个数据表的实体类生成工具

    虽然微软提供了T4模板,但是我感觉非常难用.哪儿比得上直接用脚本来写模板来的爽. 因为要给一个老项目做周边的工具,需要连接到数据库. 我习惯性用EntityFrameworkCore来做,因为毕竟从出 ...

  6. LeakCanary检测(二)

    在主方法主实现一个内存泄漏,检测到手机会发送通知,也可以用利用androidStudio自带的Profile检测内存泄漏 public class MainActivity extends AppCo ...

  7. 第二十七章 ansible变量介绍

    一.ansible变量介绍 1.概念 变量提供了便捷的方式来管理Ansible playbook的每一个项目中的动态值,比如nginx-1.6.3这个软件包的版本,在其它地方或许会反复使用,那么如果讲 ...

  8. 《JavaScript高级程序设计》——第二章在HTML使用JavaScript

    这章讲的是JavaScript在HTML中的使用,也就是<script>元素的属性.书中详细讲了async.defer.src和type四个<script>的属性. 下面是对第 ...

  9. exe打包成安装文件(界面美观)

    前言 在开发windows桌面应用过程中,软件交付时,一般都是交付安装包. 安装文件的优点 显得更正规,安装界面也可展示软件特点介绍,可自动生成桌面图标等: 安装包体积要比软件小,方便下载. 探索之路 ...

  10. 编写shell脚本的规范

    目录 编写shell脚本的一些规范 解释器 添加脚本版本和注释功能 添加脚本调试 变量命名 全局变量和局部变量 命名规范 函数命名 脚本命名 函数 引用模块或文件 脚本日志 配置文件 其他 编写she ...