TransmittableThreadLocal实现原理

最新推荐文章于 2022-11-23 10:02:48 发布
最新推荐文章于 2022-11-23 10:02:48 发布
阅读量832 收藏 1
点赞数
分类专栏： java 多线程 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mameng1988/article/details/121288315
版权

1 ThreadLocal实现原理

// ThreadLocal.set()源码
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}
ThreadLocalMap保存在Thread中：

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

可见threadLocals为Thread的内部变量，每个Thread类的实例，都有自己的threadLocals变量。

// Thread类源码
public class Thread implements Runnable {
  	......
    ThreadLocal.ThreadLocalMap threadLocals = null;
    ......
}

1.1 总结

ThreadLocal属性保存在每个线程实例中，线程实例通过Map结构管理所有的ThreadLocal属性，Map的key为ThreadLocal属性。

1.2 遇到的问题

属性在父子线程中传递的问题：

public class MainToChild implements Runnable {

    public static ThreadLocal<String> threadLocal = new ThreadLocal();

    @Override
    public void run() {
        System.out.println("child : " + Thread.currentThread().getName());
        System.out.println("child : " + threadLocal.get());
    }

    public static void main(String[] args) {

        MainToChild mainToChild = new MainToChild();
        Thread thread = new Thread(mainToChild);
        thread.start();

        threadLocal.set("main");

        System.out.println("main : " + Thread.currentThread().getName());
        System.out.println("main : " + threadLocal.get());
    }
}

ThreadLocal属性是Thread的内部变量，父子线程是不同的线程实例，显然在子线程中无法获取父线程设置的属性：

main : main
child : Thread-0
child : null
main : main

2 InheritableThreadLocal实现原理

public class MainToChild implements Runnable {

    public static InheritableThreadLocal<String> threadLocal = new InheritableThreadLocal();

    @Override
    public void run() {
        System.out.println("child name : " + Thread.currentThread().getName());
        System.out.println("child get main value : " + threadLocal.get());
        threadLocal.set("child");
        System.out.println("child value : " + threadLocal.get());

    }

    public static void main(String[] args) {

        threadLocal.set("main");

        MainToChild mainToChild = new MainToChild();
        Thread thread = new Thread(mainToChild);
        thread.start();

        System.out.println("main name : " + Thread.currentThread().getName());
        System.out.println("main value: " + threadLocal.get());
    }
}

执行结果：

main name : main
child name : Thread-0
child get main value : main
main value: main
child value : child

再看一个：

package com.sankuai.mall.consumerapi.web.controller;

import lombok.SneakyThrows;

/**
 * @author : mazhen
 * Date    : 2021/11/12
 * Time    : 3:11 下午
 * ---------------------------------------
 * Desc    :
 */
public class MainToChild implements Runnable {

    public static InheritableThreadLocal threadLocal = new InheritableThreadLocal();

    @SneakyThrows
    @Override
    public void run() {
        System.out.println("child name : " + Thread.currentThread().getName());
        System.out.println("1 child get main value : " + threadLocal.get());
        System.out.println("2 child get main value : " + threadLocal.get());
    }

    public static void main(String[] args) {

        threadLocal.set("main");

        MainToChild mainToChild = new MainToChild();
        Thread thread = new Thread(mainToChild);
        thread.start();

        threadLocal.set("again main");

        System.out.println("main name : " + Thread.currentThread().getName());
        System.out.println("main value: " + threadLocal.get());
    }

}

执行结果：

child name : Thread-0
main name : main
1 child get main value : main
main value: again main
2 child get main value : main

我们先来看下类的介绍：

This class extends ThreadLocal to provide inheritance of values from parent 
thread to child thread: when a child thread is created, the child receives 
initial values for all inheritable thread-local variables for which the parent 
has values. Normally the child's values will be identical to the parent's; 
however, the child's value can be made an arbitrary function of the parent's 
by overriding the childValue method in this class.
Inheritable thread-local variables are used in preference to ordinary 
thread-local variables when the per-thread-attribute being maintained in 
the variable (e.g., User ID, Transaction ID) must be automatically transmitted
to any child threads that are created.

再看下实现原理：

ThreadLocalMap getMap(Thread t) {
    return t.inheritableThreadLocals;
}

与ThreadLocal一样，InheritableThreadLocal保存在Thread中：

// Thread类源码
public class Thread implements Runnable {
  	......
	ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    ......
}

数据结构也是一样的，我们来看这这个属性有什么特殊逻辑（when a child thread is created, the child receives initial values for all inheritable thread-local variables for which the parent has values），下面代码在Thread类中：

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        ......
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
  		.....
}

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
}

下面的代码在ThreadLocal中：

private ThreadLocalMap(ThreadLocalMap parentMap) {
       Entry[] parentTable = parentMap.table;
       int len = parentTable.length;
       setThreshold(len);
       table = new Entry[len];

       for (int j = 0; j < len; j++) {
           Entry e = parentTable[j];
           if (e != null) {
               @SuppressWarnings("unchecked")
               ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
               if (key != null) {
                    // 需要注意childValue方法，通过重写这个方法,
                    // 可以实现自定义的拷贝逻辑
                    Object value = key.childValue(e.value);
                    Entry c = new Entry(key, value);
                    int h = key.threadLocalHashCode & (len - 1);
                    while (table[h] != null)
                            h = nextIndex(h, len);
                    table[h] = c;
                    size++;
               }
           }
       }
}

2.1 总结

如果父线程使用了InheritableThreadLocal属性，在子线程初始化的时候，会把父线程InheritableThreadLocal属性中的值，逐个拷贝到子线程的InheritableThreadLocal属性中

2.2 遇到的问题

package com.sankuai.mall.consumerapi.web.controller;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author : mazhen
 * Date    : 2021/11/12
 * Time    : 4:11 下午
 * ---------------------------------------
 * Desc    :
 */
public class ITL {

    public static InheritableThreadLocal<String> param = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        param.set("main");

        ExecutorService pool = Executors.newFixedThreadPool(1);
        pool.submit(() -> {
            System.out.println(param.get());
        });
        param.set("main2");
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.shutdown();
    }

}

执行的结果：

main
main
main

InheritableThreadLocal只会在线程池中的线程初次创建的时候，从父线程拷贝属性，而父线程再次修改这个属性时，线程池中的这个线程是无法再次感知到的。

我们在日常的开发中，很少主动new线程，都是使用线程池，而线程池中，不会频繁的创建线程，更多的场景是线程创建一次，重复使用。

再看一个例子：

package com.sankuai.mall.consumerapi.web.controller;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author : mazhen
 * Date    : 2021/11/12
 * Time    : 4:11 下午
 * ---------------------------------------
 * Desc    :
 */
public class ITL {

    public static InheritableThreadLocal<String> param = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        param.set("main");

        ExecutorService pool = Executors.newFixedThreadPool(1);
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.submit(() -> {
            param.set("child value only use in this");
            System.out.println(param.get());
        });
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.shutdown();
    }

}

执行结果：

main
child value only use in this
child value only use in this

如果线程中的属性在上次使用时被修改，下次使用后，线程中保存的属性值是上次使用时修改的值。

3 TransmittableThreadLocal实现原理

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.threadpool.TtlExecutors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author : mazhen
 * Date    : 2021/11/12
 * Time    : 4:11 下午
 * ---------------------------------------
 * Desc    :
 */
public class ITL {

    public static TransmittableThreadLocal<String> param = new TransmittableThreadLocal<>();

    public static void main(String[] args) {
        param.set("main");

        ExecutorService pool = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(1));

        pool.submit(() -> {
            System.out.println(param.get());
        });
        param.set("main2");
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.shutdown();
    }

}

执行结果：

main
main2
main2

可以看到，使用TransmittableThreadLocal并配合TtlExecutors.getTtlExecutorService()可以让子线程感知到父线程对共享变量的实时变化。

再看一个：

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.threadpool.TtlExecutors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author : mazhen
 * Date    : 2021/11/12
 * Time    : 4:11 下午
 * ---------------------------------------
 * Desc    :
 */
public class ITL {

    public static TransmittableThreadLocal<String> param = new TransmittableThreadLocal<>();

    public static void main(String[] args) {
        param.set("main");

        ExecutorService pool = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(1));

        pool.submit(() -> {
            System.out.println(param.get());
        });
        param.set("main2");
        pool.submit(() -> {
            param.set("child value only use in this");
            System.out.println(param.get());
        });
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.shutdown();
    }

}

执行结果：

main
child value only use in this
main2

而且子线程对共享变量的修改不会影响到其他子线程。

我们看下具体的实现原理：

public final void set(T value) {
     // InheritableThreadLocal.set()，这里保留了父类的特性
     super.set(value);
     if (null == value) {
         this.removeValue();
     } else {
         this.addValue();
     }

}



private void addValue() {
    if (!((Map)holder.get()).containsKey(this)) {
       ((Map)holder.get()).put(this, (Object)null);
    }

}

与ThreadLocal保存在Thread中不同，holder就保存在TransmittableThreadLocal中：

private static InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>> holder = new InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>>() {
        protected Map<TransmittableThreadLocal<?>, ?> initialValue() {
            return new WeakHashMap();
        }

        protected Map<TransmittableThreadLocal<?>, ?> childValue(Map<TransmittableThreadLocal<?>, ?> parentValue) {
            return new WeakHashMap(parentValue);
        }
    };

继续往下看就没有其它信息了，我们回过头看TtlExecutors，对普通的ExecutorService进行了封装：

public static ExecutorService getTtlExecutorService(@Nullable ExecutorService executorService) {
        return (ExecutorService)(!TtlAgent.isTtlAgentLoaded() && executorService != null && !(executorService instanceof TtlEnhanced) ? new ExecutorServiceTtlWrapper(executorService) : executorService);
    }

我们看下ExecutorServiceTtlWrapper的实现：

public <T> Future<T> submit(@Nonnull Runnable task, T result) {
    return this.executorService.submit(TtlRunnable.get(task), result);
}


public static TtlRunnable get(@Nullable Runnable runnable) {
    return get(runnable, false, false);
}


public static TtlRunnable get(@Nullable Runnable runnable, boolean releaseTtlValueReferenceAfterRun, boolean idempotent) {
    if (null == runnable) {
         return null;
    } else if (runnable instanceof TtlEnhanced) {
         if (idempotent) {
              return (TtlRunnable)runnable;
         } else {
             throw new IllegalStateException("Already TtlRunnable!");
         }
    } else {
         return new TtlRunnable(runnable, releaseTtlValueReferenceAfterRun);
    }
}

看起来核心就是TtlRunnable了：

public void run() {
     Object captured = this.capturedRef.get();
     if (captured != null && (!this.releaseTtlValueReferenceAfterRun || this.capturedRef.compareAndSet(captured, (Object)null))) {
         
         //线程执行前，备份现场
         Object backup = Transmitter.replay(captured);

         try {
             this.runnable.run();
         } finally {
             // 线程执行完成后，再用拷贝的属性还原现场
          	 // 这样就可以解决InheritableThreadLocal所面临的问题
             Transmitter.restore(backup);
         }

      } else {
          throw new IllegalStateException("TTL value reference is released after run!");
     }
}

我们找备份现场的代码看一下，其实就是把属性复制了一下：

public static Object replay(@Nonnull Object captured) {
      Map<TransmittableThreadLocal<?>, Object> capturedMap = (Map)captured;
      Map<TransmittableThreadLocal<?>, Object> backup = new HashMap();
      Iterator iterator = ((Map)TransmittableThreadLocal.holder.get()).entrySet().iterator();

      // 遍历需要复制的holder中的属性
      while(iterator.hasNext()) {
           Entry<TransmittableThreadLocal<?>, ?> next = (Entry)iterator.next();
           TransmittableThreadLocal<?> threadLocal = (TransmittableThreadLocal)next.getKey();
           // backup
           backup.put(threadLocal, threadLocal.get());
           if (!capturedMap.containsKey(threadLocal)) {
                terator.remove();
                threadLocal.superRemove();
           }
       }

       // clear the TTL values that is not in captured
       // avoid the extra TTL values after replay when run task
       setTtlValuesTo(capturedMap);
       TransmittableThreadLocal.doExecuteCallback(true);
       return backup;
}

看下下面代码的执行结果：

import com.alibaba.ttl.TransmittableThreadLocal;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author : mazhen
 * Date    : 2021/11/12
 * Time    : 6:28 下午
 * ---------------------------------------
 * Desc    :
 */
public class TTL {
    public static TransmittableThreadLocal<String> param =
            new TransmittableThreadLocal<>();

    public static void main(String[] args) {
        param.set("main");
        
        ExecutorService pool = Executors.newFixedThreadPool(1);
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.submit(() -> {
            param.set("special");
            System.out.println(param.get());
        });
        param.set("main2");
        pool.submit(() -> {
            System.out.println(param.get());
        });
        pool.shutdown();
    }
}

 

mameng1998
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从ThreadLocal谈到TransmittableThreadLocal，从使用到原理
Java技术攻略的博客
03-27 220
谈到这个其实还是蛮有意思的，因为我最近有在看SpringCloud相关的有趣的知识点，在玩那个链路追踪（sleuth+zipkin）的时候，看博客看着看着，就变成了看关于怎么自己手动实现链路追踪的文章去啦文章中提到了我今天想谈的这个知识点，顺着文章提供的链接，我就去了github上溜达。至此才有了我笔下的这篇东拼西凑的博文~在开始聊之前，不可避免的还是要先说一说大家相对熟悉的和的。知道痛点的由来，才能更清楚的产生以及使用场景。
阿里开源TransmittableThreadLocal（TTL）l的使用及原理解析
大树叶 技术专栏
02-01 439
TransmittableThreadLocal
TransmittableThreadLocal详解
hxt的博客
03-27 1843
ThreadLocal和InheritableThreadLocal学习资料：二刷Java多线程：ThreadLocal详解 线程池学习资料：二刷Java多线程：线程池详解 1、InheritableThreadLocal+线程池局限性 InheritableThreadLocal支持子线程访问在父线程中设置的线程上下文环境，其实现原理是在创建子线程时将父线程中的本地变量值复制到子线程，即复制的时机为创建子线程时 当提交一个新任务到线程池时，线程池的处理流程如下： 线程池判断线程数是否达到核心线程数且线程
transfertable-thread-local：:pushpin:TransmittableThreadLocal（TTL），缺少框架中间件的Java:trade_mark:std lib（简单和0依赖），提供了增强的InheritableThreadLocal，即使使用线程池组件也可以在线程之间传输值
02-03
:pushpin: TransmittableThreadLocal（TTL） :pushpin: | :open_book:中文文档 :wrench:功能 :backhand_index_pointing_right:在使用线程池等会池化复用线程的执行组件情况下，提供ThreadLocal值的...
transmittable-thread-local-2.12.2-API文档-中文版.zip
06-04
赠送jar包：transmittable-thread-local-2.12.2.jar； 赠送原API文档：transmittable-thread-local-2.12.2-javadoc.jar； 赠送源代码：transmittable-thread-local-2.12.2-sources.jar； 赠送Maven依赖信息文件：...
ThreadLocal垮线程池传递数据解决方案.docx
10-26
3 TransmittableThreadLocal 的实现原理：TransmittableThreadLocal 是基于ThreadLocal 和InheritableThreadLocal 的结合，能够实现跨线程池之间的数据传递。 4 TransmittableThreadLocal 的应用场景：...
详解Spring Cloud中Hystrix 线程隔离导致ThreadLocal数据丢失
08-27
Hystrix是Spring Cloud中的一种断路器实现，用于防止服务之间的级联失败。Hystrix提供了两种线程隔离模式：信号量隔离和线程隔离。在使用线程隔离的时候，Hystrix会将请求放入Hystrix的线程池中去执行。 知识点2：...
北京和平科技发展有限公司简介.pdf
10-11
北京和平科技发展有限公司简介pdf,北京和平科技发展有限公司简介
InheritableThreadLocal和TransmittableThreadLocal详解
花明的博客
08-24 1748
InheritableThreadLocal 简介 由于ThreadLocal设计之初就是为了绑定当前线程，如果希望当前线程的ThreadLocal能够被子线程使用，实现方式就会相当困难（需要用户自己在代码中传递）。在此背景下，InheritableThreadLocal应运而生。 应用 调用链追踪：在调用链系统设计中，为了优化系统运行速度，会使用多线程编程，为了保证调用链ID能够自然的在多线程间传递，需要考虑ThreadLocal传递问题（大多数系统会使用线程池技术，这已经不仅仅是InheritableT
Transmittable-Thread-Local：阿里开源的线程间上下文传递解决方案
luoxn28的专栏
03-15 2426
戳蓝字「TopCoder」关注我们哦！TTL（transmittable-thread-local）是一个线程间传递ThreadLocal，异步执行时...
ThreadLocal原理、内存泄漏以及TransmittableThreadLocal说明
m0_47704296的博客
11-23 493
ThreadLocal原理、内存泄漏以及TransmittableThreadLocal说明
从 ThreadLocal 到 TransmittableThreadLocal 的深度剖析
曳凡的博客
03-28 1203
引言 ThreadLocal 相信大家都用过，我们在需要变量只生效于线程单位时，使用 TheadLocal 能很好的帮我们把变量在不同线程中隔离开来。本篇文章主要分析一下 ThreadLocal, InheritableThreadLocal, TransmittableThreadLocal。这三者是依次推进的关系， InheritableThreadLocal对ThreadLocal做了拓展，TransmittableThreadLocal对InheritableThreadLocal做了拓展。那接下
ThreadLocal父子线程传递实现方案
热门推荐
蜗牛的专栏
09-30 2万+
前言 介绍InheritableThreadLocal之前，假设对 ThreadLocal 已经有了一定的理解，比如基本概念，原理，如果没有，可以参考：ThreadLocal源码分析解密.在讲解之前我们先列举有关ThreadLocal的几个关键点 每一个Thread线程都有属于自己的ThreadLocalMap,里面有一个弱引用的Entry(ThreadLocal,Object),
TransmittableThreadLocal 解决线程本地变量在线程池之间的传递问题
代码小司机
05-13 4474
上一个博客中提到的 InheritableThreadLocal在线程池的应用中会产生问题. 博客地址：https://blog.csdn.net/hewenbo111/article/details/80487252 因为线程池中的线程是会被复用的，所以在使用线程池进行多线程编程时，如需操作本地变量则需要特别注意！ 本次博客会演示使用 TransmittableThreadLocal 解决...
Spring Cloud中Hystrix 线程隔离导致ThreadLocal数据丢失（续）
程序猿DD
04-01 1568
前言上篇文章《Spring Cloud中Hystrix 线程隔离导致ThreadLocal数据丢失》我们对ThreadLocal数据丢失进行了详细的分析，并通过代码的方式复现了这个问题。在上篇文章的末尾我也说了思路给大家提供了，如果需要能够在Hystrix 为线程隔离模式也能正确传递数据的话，需要我们自己去修改。我这边以Zuul中自定义负载均衡策略来进行讲解，在Zuul中需要实现灰度发布的功能，需
java runnable 停止线程_Java中终止线程的方法详解
weixin_42348026的博客
02-13 7924
Java中终止线程的方式主要有三种：1、使用stop()方法，已被弃用。原因是：stop()是立即终止，会导致一些数据被到处理一部分就会被终止，而用户并不知道哪些数据被处理，哪些没有被处理，产生了不完整的“残疾”数据，不符合完整性，所以被废弃。So, forget it!2、使用volatile标志位看一个简单的例子：首先，实现一个Runnable接口，在其中定义volatile标志位，在run(...
一篇文章搞清楚TransmittalbeThreadLocal线程局部变量的实现原理
qq_34023135的博客
05-16 294
线程局部变量的实现原理 引言 在web服务开发过程中，程序通常是并发地处理多个请求，不同的请求在不同的线程中执行。类似日志追踪等信息在不同的请求中有不同的值，但因为和业务无关一般不通过参数在处理方法链上传递，为了实现在不同的线程中保存不同的数据值，在线程间的数据隔离的效果，可以使用ThreadLocal来实现功能。ThreadLocal<T>称为线程局部变量，其中的类型参数T就是线程局部变量的实际类型，一般ThreadLocal的实例被声明为静态变量，通过get和set方法可以设置当前线程.
TransmittableThreadLocal原理
最新发布
11-04
TransmittableThreadLocal是一个Java工具类，它通过继承InheritableThreadLocal类来实现线程间变量的传递。与InheritableThreadLocal不同的是，TransmittableThreadLocal可以在子线程中获取到父线程中的变量值，并且...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值