上一篇：ThreadLocal系列（二）-InheritableThreadLocal的使用及原理解析

一、基本使用

首先，TTL是用来解决ITL解决不了的问题而诞生的，所以TTL一定是支持父线程的本地变量传递给子线程这种基本操作的，ITL也可以做到，但是前面有讲过，ITL在线程池的模式下，就没办法再正确传递了，所以TTL做出的改进就是即便是在线程池模式下，也可以很好的将父线程本地变量传递下去，先来看个例子：


  2. // 需要注意的是，使用TTL的时候，要想传递的值不出问题，线程池必须得用TTL加一层代理（下面会讲这样做的目的）
  3.     private static ExecutorService executorService = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(2));
  5.     private static ThreadLocal tl = new TransmittableThreadLocal<>(); //这里采用TTL的实现
  7.     public static void main(String[] args) {
  9.         new Thread(() -> {
  11.             String mainThreadName = "main_01";
  13.             tl.set(1);
  15.             executorService.execute(() -> {
  16.                 sleep(1L);
  17.                 System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  18.             });
  20.             executorService.execute(() -> {
  21.                 sleep(1L);
  22.                 System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  23.             });
  25.             executorService.execute(() -> {
  26.                 sleep(1L);
  27.                 System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  28.             });
  30.             sleep(1L); //确保上面的会在tl.set执行之前执行
  31.             tl.set(2); // 等上面的线程池第一次启用完了，父线程再给自己赋值
  33.             executorService.execute(() -> {
  34.                 sleep(1L);
  35.                 System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  36.             });
  38.             executorService.execute(() -> {
  39.                 sleep(1L);
  40.                 System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  41.             });
  43.             executorService.execute(() -> {
  44.                 sleep(1L);
  45.                 System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  46.             });
  48.             System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), tl.get()));
  50.         }).start();
  52.         new Thread(() -> {
  54.             String mainThreadName = "main_02";
  56.             tl.set(3);
  58.             executorService.execute(() -> {
  59.                 sleep(1L);
  60.                 System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  61.             });
  63.             executorService.execute(() -> {
  64.                 sleep(1L);
  65.                 System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  66.             });
  68.             executorService.execute(() -> {
  69.                 sleep(1L);
  70.                 System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  71.             });
  73.             sleep(1L); //确保上面的会在tl.set执行之前执行
  74.             tl.set(4); // 等上面的线程池第一次启用完了，父线程再给自己赋值
  76.             executorService.execute(() -> {
  77.                 sleep(1L);
  78.                 System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  79.             });
  81.             executorService.execute(() -> {
  82.                 sleep(1L);
  83.                 System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  84.             });
  86.             executorService.execute(() -> {
  87.                 sleep(1L);
  88.                 System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  89.             });
  91.             System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), tl.get()));
  93.         }).start();
  95.     }
  97.     private static void sleep(long time) {
  98.         try {
  99.             Thread.sleep(time);
  100.         } catch (InterruptedException e) {
  101.             e.printStackTrace();
  102.         }
  103.     }

运行结果：


  2. 线程名称-Thread-2, 变量值=4
  3. 本地变量改变之前(3), 父线程名称-main_02, 子线程名称-pool-1-thread-1, 变量值=3
  4. 线程名称-Thread-1, 变量值=2
  5. 本地变量改变之前(1), 父线程名称-main_01, 子线程名称-pool-1-thread-2, 变量值=1
  6. 本地变量改变之前(1), 父线程名称-main_01, 子线程名称-pool-1-thread-1, 变量值=1
  7. 本地变量改变之前(3), 父线程名称-main_02, 子线程名称-pool-1-thread-2, 变量值=3
  8. 本地变量改变之前(3), 父线程名称-main_02, 子线程名称-pool-1-thread-2, 变量值=3
  9. 本地变量改变之前(1), 父线程名称-main_01, 子线程名称-pool-1-thread-1, 变量值=1
  10. 本地变量改变之后(2), 父线程名称-main_01, 子线程名称-pool-1-thread-2, 变量值=2
  11. 本地变量改变之后(4), 父线程名称-main_02, 子线程名称-pool-1-thread-1, 变量值=4
  12. 本地变量改变之后(4), 父线程名称-main_02, 子线程名称-pool-1-thread-1, 变量值=4
  13. 本地变量改变之后(4), 父线程名称-main_02, 子线程名称-pool-1-thread-2, 变量值=4
  14. 本地变量改变之后(2), 父线程名称-main_01, 子线程名称-pool-1-thread-1, 变量值=2
  15. 本地变量改变之后(2), 父线程名称-main_01, 子线程名称-pool-1-thread-2, 变量值=2

程序有些啰嗦，为了说明问题，加了很多说明，但至少通过上面的例子，不难发现，两个主线程里都使用线程池异步，而且值在主线程里还发生过改变，测试结果展示一切正常，由此可以知道TTL在使用线程池的情况下，也可以很好的完成传递，而且不会发生错乱。

那么是不是对普通线程异步也有这么好的支撑呢？

改造下上面的测试代码：


  2. private static ThreadLocal tl = new TransmittableThreadLocal<>();
  4.     public static void main(String[] args) {
  6.         new Thread(() -> {
  8.             String mainThreadName = "main_01";
  10.             tl.set(1);
  12.             new Thread(() -> {
  13.                 sleep(1L);
  14.                 System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  15.             }).start();
  17.             new Thread(() -> {
  18.                 sleep(1L);
  19.                 System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  20.             }).start();
  22.             new Thread(() -> {
  23.                 sleep(1L);
  24.                 System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  25.             }).start();
  27.             sleep(1L); //确保上面的会在tl.set执行之前执行
  28.             tl.set(2); // 等上面的线程池第一次启用完了，父线程再给自己赋值
  30.             new Thread(() -> {
  31.                 sleep(1L);
  32.                 System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  33.             }).start();
  35.             new Thread(() -> {
  36.                 sleep(1L);
  37.                 System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  38.             }).start();
  40.             new Thread(() -> {
  41.                 sleep(1L);
  42.                 System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  43.             }).start();
  45.             System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), tl.get()));
  47.         }).start();
  49.         new Thread(() -> {
  51.             String mainThreadName = "main_02";
  53.             tl.set(3);
  55.             new Thread(() -> {
  56.                 sleep(1L);
  57.                 System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  58.             }).start();
  60.             new Thread(() -> {
  61.                 sleep(1L);
  62.                 System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  63.             }).start();
  65.             new Thread(() -> {
  66.                 sleep(1L);
  67.                 System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  68.             }).start();
  70.             sleep(1L); //确保上面的会在tl.set执行之前执行
  71.             tl.set(4); // 等上面的线程池第一次启用完了，父线程再给自己赋值
  73.             new Thread(() -> {
  74.                 sleep(1L);
  75.                 System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  76.             }).start();
  78.             new Thread(() -> {
  79.                 sleep(1L);
  80.                 System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  81.             }).start();
  83.             new Thread(() -> {
  84.                 sleep(1L);
  85.                 System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
  86.             }).start();
  88.             System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), tl.get()));
  90.         }).start();
  92.     }

相比第一段测试代码，这一段的异步全都是普通异步，未采用线程池的方式进行异步，看下运行结果：


  2. 本地变量改变之后(4), 父线程名称-main_02, 子线程名称-Thread-14, 变量值=4
  3. 本地变量改变之前(1), 父线程名称-main_01, 子线程名称-Thread-5, 变量值=1
  4. 线程名称-Thread-1, 变量值=2
  5. 本地变量改变之前(1), 父线程名称-main_01, 子线程名称-Thread-3, 变量值=1
  6. 本地变量改变之后(2), 父线程名称-main_01, 子线程名称-Thread-11, 变量值=2
  7. 本地变量改变之前(3), 父线程名称-main_02, 子线程名称-Thread-6, 变量值=3
  8. 本地变量改变之后(4), 父线程名称-main_02, 子线程名称-Thread-12, 变量值=4
  9. 本地变量改变之后(4), 父线程名称-main_02, 子线程名称-Thread-10, 变量值=4
  10. 本地变量改变之前(3), 父线程名称-main_02, 子线程名称-Thread-8, 变量值=3
  11. 本地变量改变之前(3), 父线程名称-main_02, 子线程名称-Thread-4, 变量值=3
  12. 本地变量改变之前(1), 父线程名称-main_01, 子线程名称-Thread-7, 变量值=1
  13. 线程名称-Thread-2, 变量值=4
  14. 本地变量改变之后(2), 父线程名称-main_01, 子线程名称-Thread-9, 变量值=2
  15. 本地变量改变之后(2), 父线程名称-main_01, 子线程名称-Thread-13, 变量值=2

ok，可以看到，达到了跟第一个测试一致的结果。

到这里，通过上述两个例子，TTL的基本使用，以及其解决的问题，我们已经有了初步的了解，下面我们来解析一下其内部原理，看看TTL是怎么完成对ITL的优化的。

二、原理分析

先来看TTL里面的几个重要属性及方法

TTL定义：


  2. public class TransmittableThreadLocal extends InheritableThreadLocal

可以看到，TTL继承了ITL，意味着TTL首先具备ITL的功能。

再来看看一个重要属性holder：


  2.    /**
  3.      * 这是一个ITL类型的对象，持有一个全局的WeakMap（weakMap的key是弱引用，同TL一样，也是为了解决内存泄漏的问题），里面存放了TTL对象
  4.      * 并且重写了initialValue和childValue方法，尤其是childValue，可以看到在即将异步时父线程的属性是直接作为初始化值赋值给子线程的本地变量对象（TTL）的
  5.      */
  6.     private static InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>> holder =
  7.             new InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>>() {
  8.                 @Override
  9.                 protected Map<TransmittableThreadLocal<?>, ?> initialValue() {
  10.                     return new WeakHashMap<TransmittableThreadLocal<?>, Object>();
  11.                 }
  13.                 @Override
  14.                 protected Map<TransmittableThreadLocal<?>, ?> childValue(Map<TransmittableThreadLocal<?>, ?> parentValue) {
  15.                     return new WeakHashMap<TransmittableThreadLocal<?>, Object>(parentValue);
  16.                 }
  17.             };

再来看下set和get：

  1. //下面的方法均属于TTL类
  2. @Override
  3.     public final void set(T value) {
  4.         super.set(value);
  5.         if (null == value) removeValue();
  6.         else addValue();
  7.     }
  9.     @Override
  10.     public final T get() {
  11.         T value = super.get();
  12.         if (null != value) addValue();
  13.         return value;
  14.     }
  16.     private void removeValue() {
  17.         holder.get().remove(this); //从holder持有的map对象中移除
  18.     }
  20.     private void addValue() {
  21.         if (!holder.get().containsKey(this)) {
  22.             holder.get().put(this, null); //从holder持有的map对象中添加
  23.         }
  24.     }

TTL里先了解上述的几个方法及对象，可以看出，单纯的使用TTL是达不到支持线程池本地变量的传递的，通过第一部分的例子，可以发现，除了要启用TTL，还需要通过TtlExecutors.getTtlExecutorService包装一下线程池才可以，那么，下面就来看看在程序即将通过线程池异步的时候，TTL帮我们做了哪些操作（这一部分是TTL支持线程池传递的核心部分）：

首先打开包装类，看下execute方法在执行时做了些什么。

  1. // 此方法属于线程池包装类ExecutorTtlWrapper
  2. @Override
  3.     public void execute(@Nonnull Runnable command) {
  4.         executor.execute(TtlRunnable.get(command)); //这里会把Rannable包装一层，这是关键，有些逻辑处理，需要在run之前执行
  5.     }
  7.     // 对应上面的get方法，返回一个TtlRunnable对象，属于TtLRannable包装类
  8.     @Nullable
  9.     public static TtlRunnable get(@Nullable Runnable runnable) {
  10.         return get(runnable, false, false);
  11.     }
  13.     // 对应上面的get方法
  14.     @Nullable
  15.     public static TtlRunnable get(@Nullable Runnable runnable, boolean releaseTtlValueReferenceAfterRun, boolean idempotent) {
  16.         if (null == runnable) return null;
  18.         if (runnable instanceof TtlEnhanced) { // 若发现已经是目标类型了（说明已经被包装过了）直接返回
  19.             // avoid redundant decoration, and ensure idempotency
  20.             if (idempotent) return (TtlRunnable) runnable;
  21.             else throw new IllegalStateException("Already TtlRunnable!");
  22.         }
  23.         return new TtlRunnable(runnable, releaseTtlValueReferenceAfterRun); //最终初始化
  24.     }
  26.     // 对应上面的TtlRunnable方法
  27.     private TtlRunnable(@Nonnull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
  28.         this.capturedRef = new AtomicReference<Object>(capture()); //这里将捕获后的父线程本地变量存储在当前对象的capturedRef里
  29.         this.runnable = runnable;
  30.         this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
  31.     }
  33.     // 对应上面的capture方法，用于捕获当前线程（父线程）里的本地变量，此方法属于TTL的静态内部类Transmitter
  34.     @Nonnull
  35.     public static Object capture() {
  36.         Map<TransmittableThreadLocal<?>, Object> captured = new HashMap<TransmittableThreadLocal<?>, Object>();
  37.         for (TransmittableThreadLocal<?> threadLocal : holder.get().keySet()) { // holder里目前存放的k-v里的key，就是需要传给子线程的TTL对象
  38.             captured.put(threadLocal, threadLocal.copyValue());
  39.         }
  40.         return captured; // 这里返回的这个对象，就是当前将要使用线程池异步出来的子线程，所继承的本地变量合集
  41.     }
  43.     // 对应上面的copyValue，简单的将TTL对象里的值返回（结合之前的源码可以知道get方法其实就是获取当前线程（父线程）里的值，调用super.get方法）
  44.     private T copyValue() {
  45.         return copy(get());
  46.     }
  47.     protected T copy(T parentValue) {
  48.         return parentValue;
  49.     }

结合上述代码，大致知道了在线程池异步之前需要做的事情，其实就是把当前父线程里的本地变量取出来，然后赋值给Rannable包装类里的capturedRef属性，到此为止，下面会发生什么，我们大致上可以猜出来了，接下来大概率会在run方法里，将这些捕获到的值赋给子线程的holder赋对应的TTL值，那么我们继续往下看Rannable包装类里的run方法是怎么实现的：

  1. //run方法属于Rannable的包装类TtlRunnable
  2. @Override
  3.     public void run() {
  4.         Object captured = capturedRef.get(); // 获取由之前捕获到的父线程变量集
  5.         if (captured == null || releaseTtlValueReferenceAfterRun && !capturedRef.compareAndSet(captured, null)) {
  6.             throw new IllegalStateException("TTL value reference is released after run!");
  7.         }
  9.         /**
  10.          * 重点方法replay，此方法用来给当前子线程赋本地变量，返回的backup是此子线程原来就有的本地变量值（原生本地变量，下面会详细讲），
  11.          * backup用于恢复数据（如果任务执行完毕，意味着该子线程会归还线程池，那么需要将其原生本地变量属性恢复）
  12.          */
  13.         Object backup = replay(captured);
  14.         try {
  15.             runnable.run(); // 执行异步逻辑
  16.         } finally {
  17.             restore(backup); // 结合上面对于replay的解释，不难理解，这个方法就是用来恢复原有值的
  18.         }
  19.     }

根据上述代码，我们看到了TTL在异步任务执行前，会先进行赋值操作（就是拿着异步发生时捕获到的父线程的本地变量，赋给自己），当任务执行完，就恢复原生的自己本身的线程变量值。

下面来具体看这俩方法：

  1. //下面的方法均属于TTL的静态内部类Transmittable
  2. @Nonnull
  3.     public static Object replay(@Nonnull Object captured) {
  4.         @SuppressWarnings("unchecked")
  5.         Map<TransmittableThreadLocal<?>, Object> capturedMap = (Map<TransmittableThreadLocal<?>, Object>) captured; //使用此线程异步时捕获到的父线程里的本地变量值
  6.         Map<TransmittableThreadLocal<?>, Object> backup = new HashMap<TransmittableThreadLocal<?>, Object>(); //当前线程原生的本地变量，用于使用完线程后恢复用
  8.         //注意：这里循环的是当前子线程原生的本地变量集合，与本方法相反，restore方法里循环这个holder是指：该线程运行期间产生的变量+父线程继承来的变量
  9.         for (Iterator<? extends Map.Entry<TransmittableThreadLocal<?>, ?>> iterator = holder.get().entrySet().iterator();
  10.              iterator.hasNext(); ) {
  11.             Map.Entry<TransmittableThreadLocal<?>, ?> next = iterator.next();
  12.             TransmittableThreadLocal<?> threadLocal = next.getKey();
  14.             backup.put(threadLocal, threadLocal.get()); // 所有原生的本地变量都暂时存储在backup里，用于之后恢复用
  16.             /**
  17.              * 检查，如果捕获到的线程变量里，不包含当前原生变量值，则从当前原生变量里清除掉，对应的线程本地变量也清掉
  18.              * 这就是为什么会将原生变量保存在backup里的原因，为了恢复原生值使用
  19.              * 那么，为什么这里要清除掉呢？因为从使用这个子线程做异步那里，捕获到的本地变量并不包含原生的变量，当前线程
  20.              * 在做任务时的首要目标，是将父线程里的变量完全传递给任务，如果不清除这个子线程原生的本地变量，
  21.              * 意味着很可能会影响到任务里取值的准确性。
  22.              *
  23.              * 打个比方，有ttl对象tl，这个tl在线程池的某个子线程里存在对应的值2，当某个主线程使用该子线程做异步任务时
  24.              * tl这个对象在当前主线程里没有值，那么如果不进行下面这一步的操作，那么在使用该子线程做的任务里就可以通过
  25.              * 该tl对象取到值2，不符合预期
  26.              */
  27.             if (!capturedMap.containsKey(threadLocal)) {
  28.                 iterator.remove();
  29.                 threadLocal.superRemove();
  30.             }
  31.         }
  33.         // 这一步就是直接把父线程本地变量赋值给当前线程了（这一步起就刷新了holder里的值了，具体往下看该方法，在异步线程运行期间，还可能产生别的本地变量，比如在真正的run方法内的业务代码，再用一个tl对象设置一个值）
  34.         setTtlValuesTo(capturedMap);
  36.         // 这个方法属于扩展方法，ttl本身支持重写异步任务执行前后的操作，这里不再具体赘述
  37.         doExecuteCallback(true);
  39.         return backup;
  40.     }
  42.     // 结合之前Rannable包装类的run方法来看，这个方法就是使用上面replay记录下的原生线程变量做恢复用的
  43.     public static void restore(@Nonnull Object backup) {
  44.         @SuppressWarnings("unchecked")
  45.         Map<TransmittableThreadLocal<?>, Object> backupMap = (Map<TransmittableThreadLocal<?>, Object>) backup;
  46.         // call afterExecute callback
  47.         doExecuteCallback(false);
  49.         // 注意，这里的holder取出来的，实际上是replay方法设置进去的关于父线程里的所有变量（结合上面来看，就是：该线程运行期间产生的变量+父线程继承来的变量）
  50.         for (Iterator<? extends Map.Entry<TransmittableThreadLocal<?>, ?>> iterator = holder.get().entrySet().iterator();
  51.              iterator.hasNext(); ) {
  52.             Map.Entry<TransmittableThreadLocal<?>, ?> next = iterator.next();
  53.             TransmittableThreadLocal<?> threadLocal = next.getKey();
  55.             /**
  56.              * 同样的，如果子线程原生变量不包含某个父线程传来的对象，那么就删除，可以思考下，这里的清除跟上面replay里的有什么不同？
  57.              * 这里会把不属于原生变量的对象给删除掉（这里被删除掉的可能是父线程继承下来的，也可能是异步任务在执行时产生的新值）
  58.              */
  59.             if (!backupMap.containsKey(threadLocal)) {
  60.                 iterator.remove();
  61.                 threadLocal.superRemove();
  62.             }
  63.         }
  65.         // 同样调用这个方法，进行值的恢复
  66.         setTtlValuesTo(backupMap);
  67.     }
  69.     // 真正给当前子线程赋值的方法，对应上面的setTtlValuesTo方法
  70.     private static void setTtlValuesTo(@Nonnull Map<TransmittableThreadLocal<?>, Object> ttlValues) {
  71.         for (Map.Entry<TransmittableThreadLocal<?>, Object> entry : ttlValues.entrySet()) {
  72.             @SuppressWarnings("unchecked")
  73.             TransmittableThreadLocal<Object> threadLocal = (TransmittableThreadLocal<Object>) entry.getKey();
  74.             threadLocal.set(entry.getValue()); //赋值，注意，从这里开始，子线程的holder里的值会被重新赋值刷新，可以参照上面ttl的set方法的实现
  75.         }
  76.     }

ok，到这里基本上把TTL比较核心的代码看完了，下面整理下整个流程，这是官方给出的时序图：

图2-1

上图第一行指的是类名称，下面的流程指的是类所做的事情，根据上面罗列出来的源码，结合这个时序图，可以比较直观一些的理解整个流程。

三、TTL中线程池子线程原生变量的产生

这一节是为了验证上面replay和restore，现在通过一个例子来验证下，先把源码down下来，在源码的restore和replay上分别加上输出语句，遍历holder：


  2. //replay前后打印holder里面的值
  3. public static Object replay(@Nonnull Object captured) {
  4.             @SuppressWarnings("unchecked")
  5.             Map<TransmittableThreadLocal<?>, Object> capturedMap = (Map<TransmittableThreadLocal<?>, Object>) captured;
  6.             Map<TransmittableThreadLocal<?>, Object> backup = new HashMap<TransmittableThreadLocal<?>, Object>();
  7.             System.out.println("--------------------replay前置，当前拿到的holder里的TTL列表");
  8.             for (Iterator<? extends Map.Entry<TransmittableThreadLocal<?>, ?>> iterator = holder.get().entrySet().iterator();
  9.                  iterator.hasNext(); ) {
  10.                 Map.Entry<TransmittableThreadLocal<?>, ?> next = iterator.next();
  11.                 TransmittableThreadLocal<?> threadLocal = next.getKey();
  12.                 System.out.println(String.format("replay前置里拿到原生的ttl_k=%s, ttl_value=%s", threadLocal.hashCode(), threadLocal.get()));
  13.             }
  15.             for...//代码省略，具体看上面
  17.             setTtlValuesTo(capturedMap);
  19.             doExecuteCallback(true);
  21.             System.out.println("--------------------reply后置，当前拿到的holder里的TTL列表");
  22.             for (Iterator<? extends Map.Entry<TransmittableThreadLocal<?>, ?>> iterator = holder.get().entrySet().iterator();
  23.                  iterator.hasNext(); ) {
  24.                 Map.Entry<TransmittableThreadLocal<?>, ?> next = iterator.next();
  25.                 TransmittableThreadLocal<?> threadLocal = next.getKey();
  26.                 System.out.println(String.format("replay后置里拿到原生的ttl_k=%s, ttl_value=%s", threadLocal.hashCode(), threadLocal.get()));
  27.             }
  29.             return backup;
  30.         }
  32. //restore前后打印holder里面的值
  33. public static void restore(@Nonnull Object backup) {
  34.             @SuppressWarnings("unchecked")
  35.             Map<TransmittableThreadLocal<?>, Object> backupMap = (Map<TransmittableThreadLocal<?>, Object>) backup;
  36.             // call afterExecute callback
  37.             doExecuteCallback(false);
  39.             System.out.println("--------------------restore前置，当前拿到的holder里的TTL列表");
  40.             for (Iterator<? extends Map.Entry<TransmittableThreadLocal<?>, ?>> iterator = holder.get().entrySet().iterator();
  41.                  iterator.hasNext(); ) {
  42.                 Map.Entry<TransmittableThreadLocal<?>, ?> next = iterator.next();
  43.                 TransmittableThreadLocal<?> threadLocal = next.getKey();
  44.                 System.out.println(String.format("restore前置里拿到当前线程内变量，ttl_k=%s, ttl_value=%s", threadLocal.hashCode(), threadLocal.get()));
  45.             }
  47.             for...//省略代码，具体具体看上面
  49.             setTtlValuesTo(backupMap);
  51.             System.out.println("--------------------restore后置，当前拿到的holder里的TTL列表");
  52.             for (Iterator<? extends Map.Entry<TransmittableThreadLocal<?>, ?>> iterator = holder.get().entrySet().iterator();
  53.                  iterator.hasNext(); ) {
  54.                 Map.Entry<TransmittableThreadLocal<?>, ?> next = iterator.next();
  55.                 TransmittableThreadLocal<?> threadLocal = next.getKey();
  56.                 System.out.println(String.format("restore后置里拿到当前线程内变量，ttl_k=%s, ttl_value=%s", threadLocal.hashCode(), threadLocal.get()));
  57.             }
  58.         }

代码这样做的目的，就是要说明线程池所谓的原生本地变量是怎么产生的，以及replay和restore是怎么设置和恢复的，下面来看个简单的例子：


  2. private static ExecutorService executorService = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(1));
  4.     private static ThreadLocal tl = new TransmittableThreadLocal();
  5.     private static ThreadLocal tl2 = new TransmittableThreadLocal();
  7.     public static void main(String[] args) throws InterruptedException {
  9.         tl.set(1);
  10.         tl2.set(2);
  12.         executorService.execute(new Runnable() {
  13.             @Override
  14.             public void run() {
  15.                 try {
  16.                     Thread.sleep(1000L);
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         });
  22.     }

运行结果如下：


  2. --------------------replay前置，当前拿到的holder里的TTL列表
  3. replay前置里拿到原生的ttl_k=1259475182, ttl_value=2
  4. replay前置里拿到原生的ttl_k=929338653, ttl_value=1
  5. --------------------reply后置，当前拿到的holder里的TTL列表
  6. replay后置里拿到原生的ttl_k=1259475182, ttl_value=2
  7. replay后置里拿到原生的ttl_k=929338653, ttl_value=1
  8. --------------------restore前置，当前拿到的holder里的TTL列表
  9. restore前置里拿到当前线程内变量，ttl_k=1259475182, ttl_value=2
  10. restore前置里拿到当前线程内变量，ttl_k=929338653, ttl_value=1
  11. --------------------restore后置，当前拿到的holder里的TTL列表
  12. restore后置里拿到当前线程内变量，ttl_k=1259475182, ttl_value=2
  13. restore后置里拿到当前线程内变量，ttl_k=929338653, ttl_value=1

我们会发现，原生值产生了，从异步开始，就确定了线程池里的线程具备了1和2的值，那么，再来改动下上面的测试代码：


  2. public static void main(String[] args) throws InterruptedException {
  4.         tl.set(1);
  6.         executorService.execute(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 try {
  10.                     Thread.sleep(100L);
  11.                 } catch (InterruptedException e) {
  12.                     e.printStackTrace();
  13.                 }
  14.             }
  15.         });
  17.         Thread.sleep(1000L);
  19.         tl2.set(2);//较第一次换下位置，换到第一次使用线程池后执行（这意味着下面这次异步不会再触发Thread的init方法了）
  21.         System.out.println("---------------------------------------------------------------------------------");
  22.         executorService.execute(new Runnable() {
  23.             @Override
  24.             public void run() {
  25.                 try {
  26.                     Thread.sleep(1000L);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.             }
  31.         });
  32.     }

运行结果为：


  2. --------------------replay前置，当前拿到的holder里的TTL列表
  3. replay前置里拿到原生的ttl_k=929338653, ttl_value=1
  4. --------------------reply后置，当前拿到的holder里的TTL列表
  5. replay后置里拿到原生的ttl_k=929338653, ttl_value=1
  6. --------------------restore前置，当前拿到的holder里的TTL列表
  7. restore前置里拿到当前线程内变量，ttl_k=929338653, ttl_value=1
  8. --------------------restore后置，当前拿到的holder里的TTL列表
  9. restore后置里拿到当前线程内变量，ttl_k=929338653, ttl_value=1
  10. ---------------------------------------------------------------------------------
  11. --------------------replay前置，当前拿到的holder里的TTL列表
  12. replay前置里拿到原生的ttl_k=929338653, ttl_value=1
  13. --------------------reply后置，当前拿到的holder里的TTL列表
  14. replay后置里拿到原生的ttl_k=1020371697, ttl_value=2
  15. replay后置里拿到原生的ttl_k=929338653, ttl_value=1
  16. --------------------restore前置，当前拿到的holder里的TTL列表
  17. restore前置里拿到当前线程内变量，ttl_k=1020371697, ttl_value=2
  18. restore前置里拿到当前线程内变量，ttl_k=929338653, ttl_value=1
  19. --------------------restore后置，当前拿到的holder里的TTL列表
  20. restore后置里拿到当前线程内变量，ttl_k=929338653, ttl_value=1

可以发现，第一次异步时，只有一个值被传递了下去，然后第二次异步，新加了一个tl2的值，但是看第二次异步的打印，会发现，restore恢复后，仍然是第一次异步发生时放进去的那个tl的值。

通过上面的例子，基本可以确认，所谓线程池内线程的本地原生变量，其实是第一次使用线程时被传递进去的值，我们之前有说过TTL是继承至ITL的，之前的文章也说过，线程池第一次启用时是会触发Thread的init方法的，也就是说，在第一次异步时拿到的主线程的变量会被传递给子线程，作为子线程的原生本地变量保存起来，后续是replay操作和restore操作也是围绕着这个原生变量（即原生holder里的值）来进行设置、恢复的，设置的是当前父线程捕获到的本地变量，恢复的是子线程原生本地变量。

holder里持有的可以理解就是当前线程内的所有本地变量，当子线程将异步任务执行完毕后，会执行restore进行恢复原生本地变量，具体参照上面的代码和测试代码。

四、总结

到这里基本上确认了TTL是如何进行线程池传值的，以及被包装的run方法执行异步任务之前，会使用replay进行设置父线程里的本地变量给当前子线程，任务执行完毕，会调用restore恢复该子线程原生的本地变量（目前原生本地变量的产生，就只碰到上述测试代码中的这一种情况，即线程第一次使用时通过ITL属性以及Thread的init方法传给子线程，还不太清楚有没有其他方式设置）。

其实，正常程序里想要完成线程池上下文传递，使用TL就足够了，我们可以效仿TTL包装线程池对象的原理，进行值传递，异步任务结束后，再remove，以此类推来完成线程池值传递，不过这种方式过于单纯，且要求上下文为只读对象，否则子线程存在写操作，就会发生上下文污染。

TTL项目地址（可以详细了解下它的其他特性和用法）：https://github.com/alibaba/transmittable-thread-local

ThreadLocal系列（三）-TransmittableThreadLocal的使用及原理解析的更多相关文章

  1. 从零开始实现lmax-Disruptor队列（三）多线程消费者WorkerPool原理解析

    MyDisruptor V3版本介绍 在v2版本的MyDisruptor实现多消费者.消费者组间依赖功能后.按照计划,v3版本的MyDisruptor需要支持多线程消费者的功能. 由于该文属于系列博客 ...

  2. android黑科技系列——Apk的加固(加壳)原理解析和实现

    一.前言 今天又到周末了,憋了好久又要出博客了,今天来介绍一下Android中的如何对Apk进行加固的原理.现阶段.我们知道Android中的反编译工作越来越让人操作熟练,我们辛苦的开发出一个apk, ...

  3. jdk8系列三、jdk8之stream原理及流创建、排序、转换等处理

    一.为什么需要 Stream Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念.它也不同于 StAX ...

  4. 【权限管理系统】Spring security（三）---认证过程（原理解析，demo）

      在前面两节Spring security (一)架构框架-Component.Service.Filter分析和Spring Security(二)--WebSecurityConfigurer配 ...

  5. ThreadLocal系列（二）-InheritableThreadLocal的使用及原理解析

    ThreadLocal系列之InheritableThreadLocal的使用及原理解析(源码基于java8) 上一篇:ThreadLocal系列(一)-ThreadLocal的使用及原理解析 下一篇 ...

  6. 从零开始实现lmax-Disruptor队列（四）多线程生产者MultiProducerSequencer原理解析

    MyDisruptor V4版本介绍 在v3版本的MyDisruptor实现多线程消费者后.按照计划,v4版本的MyDisruptor需要支持线程安全的多线程生产者功能. 由于该文属于系列博客的一部分 ...

  7. 从零开始实现lmax-Disruptor队列（五）Disruptor DSL风格API原理解析

    MyDisruptor V5版本介绍 在v4版本的MyDisruptor实现多线程生产者后.按照计划,v5版本的MyDisruptor需要支持更便于用户使用的DSL风格的API. 由于该文属于系列博客 ...

  8. 从零开始实现lmax-Disruptor队列（六）Disruptor 解决伪共享、消费者优雅停止实现原理解析

    MyDisruptor V6版本介绍 在v5版本的MyDisruptor实现DSL风格的API后.按照计划,v6版本的MyDisruptor作为最后一个版本,需要对MyDisruptor进行最终的一些 ...

  9. Spring Boot干货系列：（三）启动原理解析

    Spring Boot干货系列:(三)启动原理解析 2017-03-13 嘟嘟MD 嘟爷java超神学堂 前言 前面几章我们见识了SpringBoot为我们做的自动配置,确实方便快捷,但是对于新手来说 ...

随机推荐

  1. rsync同步常用命令[转载]

    转载:http://blog.csdn.net/niushuai666/article/details/16880061 如果你是一位运维工程师,你很可能会面对几十台.几百台甚至上千台服务器,除了批量 ...

  2. IntelliJ IDEA包名在一行

    1.导入项目必须正确 选择左上角File--->NEw---->Module from Existing Sources 2.根据路径找到项目,如果是maven项目需要找到其pom.xml ...

  3. rinetd小记

    官网:http://www.boutell.com/rinetd/ 下载地址:http://www.boutell.com/rinetd/http/rinetd.tar.gz 编译安装: 对于Wind ...

  4. Linux中许多常用命令是必须掌握的，这里将我学linux入门时学的一些常用的基本命令分享给大家一下，希望可以帮助你们。

    Linux中许多常用命令是必须掌握的,这里将我学linux入门时学的一些常用的基本命令分享给大家一下,希望可以帮助你们. 这个是我将鸟哥书上的进行了一下整理的,希望不要涉及到版权问题. 1.显示日期的 ...

  5. vc 使窗口置顶 在最前面

    bool SetWindowTop(CWnd* pWnd){ if(!pWnd) {   return false; } if(pWnd->GetExStyle()&WS_EX_TOPM ...

  6. Oracle EBS R12多组织访问架构

    关于R12的新特性Multi-Org Access Control(MOAC).Oracle宣传的好处主要有:1.enable users to access to secured data in o ...

  7. [LeetCode 题解]: Rotate List

    Given a list, rotate the list to the right by k places, where k is non-negative. For example:Given 1 ...

  8. MVP社区巡讲 12月5日北京站| 12月12日上海站

    2015年底的社区巡讲Powered MVP Roadshow正式启动啦!12月5日周六下午北京场,12月12日周六下午上海场. 欢迎各位邀请您的同事朋友来参加MVP的社区活动,也邀请您发送活动信息( ...

  9. C#——Socket

    最近公司让我搞个socket小程序(服务端). 主要的功能:客户端发字符串到服务端,服务端接收后在界面上显示. 参照了网上许多代码,自己从中修改整理代码. public Form4() { Initi ...

  10. Js异常捕获

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...