InheritableThreadLocal

子线程是会继承父线程的数据的。。。。但是记住，该类是会有，线程池中线程的复用问题的，，所以在一定情况下还是需要代码使用者自己将东西卸载掉，这种还是使用阿里巴巴的TTL作为替换吧，这个ttl不存在线程池的复用问题，不过线程池需要额外包装一下

public class InheritableThreadLocalDemo {
    static ThreadLocal<String> local = new ThreadLocal<>();
    static ThreadLocal<String> local2 = new InheritableThreadLocal<>();
    @Test
    public void test1() {
        local.set("haode");
        local2.set("haode");
        MyThread myThread = new MyThread();
        myThread.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
        local.set("xxxx");
        local2.set("xxx");
    }
    static class MyThread extends Thread {
        public void run() {
            System.out.println(local.get());
        }
    }
    static class MyThread2 extends Thread {
        @Override
        public void run() {
            System.out.println(local2.get());
        }
    }
}

ttl

代码有部分是参考网上，如下情况，只有线程池被包装，然后采用TTL方式，才能够解决所有的问题

private static ExecutorService executorService = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(2));
private static ExecutorService executorService1 = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(2));
//    private static ThreadLocal tl = new InheritableThreadLocal(); //这里采用TTL的实现
private static ThreadLocal tl = new TransmittableThreadLocal(); //这里采用TTL的实现
public static void main(String[] args) {
    new Thread(() -> {
        String mainThreadName = "main_01";
        tl.set(1);
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        sleep(1L); //确保上面的会在tl.set执行之前执行
        tl.set(2); // 等上面的线程池第一次启用完了，父线程再给自己赋值
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), tl.get()));
    }).start();
    new Thread(() -> {
        String mainThreadName = "main_02";
        tl.set(3);
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        sleep(1L); //确保上面的会在tl.set执行之前执行
        tl.set(4); // 等上面的线程池第一次启用完了，父线程再给自己赋值
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        executorService.execute(() -> {
            sleep(1L);
            executorService1.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), tl.get()));
            });
        });
        System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), tl.get()));
    }).start();
}
private static void sleep(long time) {
    try {
        Thread.sleep(time);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}