ThreadLocal InheritableThreadLocal TransmittableThreadLocal的使用以及原理

ThreadLocal

每个线程向ThreadLocal设置值，再取值，实现线程之间的隔离

public class ThreadLocalCase1 {
    
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    
    public static void main(String[] args) {
        Random random = new Random(); 
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(() -> {
                int value = random.nextInt(10000);
                threadLocal.set(value);
                System.out.println(Thread.currentThread().getName() + "开始执行，放入值，值为 : " + value);
                System.out.println(Thread.currentThread().getName() + "结束执行，进行取值，值为 : " + threadLocal.get());
            }); 
            thread.setName("thread-" + i); 
            thread.start();
        }
    }
}

结果

thread-0开始执行，放入值，值为 : 7406
thread-4开始执行，放入值，值为 : 5258
thread-3开始执行，放入值，值为 : 9672
thread-2开始执行，放入值，值为 : 8583
thread-1开始执行，放入值，值为 : 9311
thread-2结束执行，进行取值，值为 : 8583
thread-3结束执行，进行取值，值为 : 9672
thread-4结束执行，进行取值，值为 : 5258
thread-0结束执行，进行取值，值为 : 7406
thread-1结束执行，进行取值，值为 : 9311

实现了线程之间的隔离性

主线程向ThreadLocal设置值，每个子线程再取值

public class ThreadLocalCase2 {
    
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
      
    public static void main(String[] args) {
        Random random = new Random();
        int value = random.nextInt(10000);
        threadLocal.set(value);
        System.out.println(Thread.currentThread().getName() + "放入值，值为 : " + value);
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
        });
        thread.setName("thread-1");
        thread.start();
        System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
    }
}

结果

main放入值，值为 : 3831
main进行取值，值为 : 3831
thread-1进行取值，值为 : null

发现主线程向ThreadLocal设置值，每个子线程再取值时为null，这时需要换用InheritableThreadLocal

InheritableThreadLocal

主线程向InheritableThreadLocal设置值，子线程再取值

public class ThreadLocalCase2 {
    
    private static InheritableThreadLocal<Integer> threadLocal = new InheritableThreadLocal<>();
    
    public static void main(String[] args) {
        Random random = new Random();
        int value = random.nextInt(10000);
        threadLocal.set(value);
        System.out.println(Thread.currentThread().getName() + "放入值，值为 : " + value);
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
        });
        thread.setName("thread-1");
        thread.start();
        System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
    }
}

结果

main放入值，值为 : 2046
main进行取值，值为 : 2046
thread-1进行取值，值为 : 2046

public class ThreadLocalCase3 {
    private static ExecutorService executor = Executors.newFixedThreadPool(2);
    private static InheritableThreadLocal<Integer> threadLocal = new InheritableThreadLocal<>();
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Random random = new Random();
            int value = random.nextInt(10000);
            threadLocal.set(value);
            System.out.println(Thread.currentThread().getName() + "放入值，值为 : " + value);
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
            });
            System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
            threadLocal.remove();
        }
    }
}

结果

main放入值，值为 : 8525
main进行取值，值为 : 8525
main放入值，值为 : 7802
main进行取值，值为 : 7802
pool-1-thread-1进行取值，值为 : 8525
main放入值，值为 : 3570
pool-1-thread-2进行取值，值为 : 7802
main进行取值，值为 : 3570
pool-1-thread-1进行取值，值为 : 8525
main放入值，值为 : 5081
main进行取值，值为 : 5081
pool-1-thread-2进行取值，值为 : 7802
main放入值，值为 : 4829
main进行取值，值为 : 4829
pool-1-thread-1进行取值，值为 : 8525

结果发现线程池取出了两次7802和三次8525，主线程中设置的3570、5081、4829在线程池中没有被取出，发生了错误。
这是由于InheritableThreadLocal会保证子线程能读取父线程中的数据，但线程池中的核心线程是复用的，所以有可能会发生重复读取的情况。

TransmittableThreadLocal

开启循环，每个循环中主线程使用InheritableThreadLocal进行设置，使用线程池来进行取值，解决线程复用产生的问题

public class ThreadLocalCase4 {
    
    private static ExecutorService executor = Executors.newFixedThreadPool(2);
    
    private static TransmittableThreadLocal<Integer> threadLocal = new TransmittableThreadLocal<>();
    
    public static void main(String[] args) {
        
        for (int i = 0; i < 5; i++) {
            Random random = new Random();
            int value = random.nextInt(10000);
            threadLocal.set(value);
            System.out.println(Thread.currentThread().getName() + "放入值，值为 : " + value);
            executor.execute(TtlRunnable.get(() -> {
                System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
            }));
            System.out.println(Thread.currentThread().getName() + "进行取值，值为 : " + threadLocal.get());
            threadLocal.remove();
        }
        
    }
}

结果

main放入值，值为 : 974
main进行取值，值为 : 974
main放入值，值为 : 4545
main进行取值，值为 : 4545
main放入值，值为 : 5901
pool-1-thread-1进行取值，值为 : 974
main进行取值，值为 : 5901
pool-1-thread-1进行取值，值为 : 5901
pool-1-thread-2进行取值，值为 : 4545
main放入值，值为 : 3716
main进行取值，值为 : 3716
pool-1-thread-1进行取值，值为 : 3716
main放入值，值为 : 2452
main进行取值，值为 : 2452
pool-1-thread-2进行取值，值为 : 2452

结果是即使线程池的线程被复用，读取的结果也是正常的

ThreadLocal原理

Thread

public class Thread implements Runnable {
   //省略....
   
    /* 
     * 当前线程的ThreadLocalMap，主要存储该线程自身的ThreadLocal
     */
    ThreadLocal.ThreadLocalMap threadLocals = null;

   //省略....
}

ThreadLocal类：
- ThreadLocal是一个泛型类，用于存储每个线程的本地变量副本。
  每个线程通过ThreadLocal实例获取和操作自己的变量副本，避免了多线程间的资源竞争。
ThreadLocalMap：
- ThreadLocalMap是ThreadLocal的内部静态类，用于存储线程局部变量。
  每个线程都有一个独立的ThreadLocalMap实例，用来存储该线程的ThreadLocal变量。
  ThreadLocalMap以ThreadLocal实例作为键，实际存储的值作为值。
get()和set()方法：
- 使用ThreadLocal的get()方法，可以获取当前线程的ThreadLocal变量。
  使用ThreadLocal的set()方法，可以设置当前线程的ThreadLocal变量。
  get()和set()方法内部会调用Thread.currentThread()获取当前线程，然后在该线程的ThreadLocalMap中查找或设置对应的值。
  
  内存泄露问题
ThreadLocalMap中的键使用弱引用：
- ThreadLocalMap中的键是对ThreadLocal实例的弱引用。当没有强引用指向ThreadLocal实例时，垃圾回收器会回收这个ThreadLocal实例，导致ThreadLocalMap中的键变为null。
- jdk1.8环境下的ThreadLocal采取嗅探机制，将调用get或set方法时，会主动探测是否含有key为空的value没有被回收的情况，如果有会主动清理。但我们依旧要在使用完后主动的调用remove

InheritableThreadLocal原理

InheritableThreadLocal重写的方法

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    
    protected T childValue(T parentValue) {
        return parentValue;
    }

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

    
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

Thread结构

public class Thread implements Runnable {
    //省略....
    /* 
     * 存储本线程自身的ThreadLocal
     */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * 从父线程集成而来的ThreadLocalMap，
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    
    //省略....
}

主线程中调用InheritableThreadLocal的set方法
set依旧是ThreadLocal中

public void set(T value) {
    Thread t = Thread.currentThread();
    //被InheritableThreadLocal重写，第一次为空
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        map.set(this, value);
    } else {
    	//被InheritableThreadLocal重写，创建ThreadLocalMap赋值给inheritableThreadLocals变量
        createMap(t, value);
    }
}

这时就是Thread中的inheritableThreadLocals变量存储ThreadLocalMap

子线程初始化

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {

    //省略....
    
    //inheritThreadLocals为true
    //parent.inheritableThreadLocals就是在主线程进行set的时候生成为所以不为null
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

    //省略....        
    
}

ThreadLocal.createInheritedMap(parent.inheritableThreadLocals)就是将主线程的ThreadLocalMap拷贝到子线程中

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

/**
 * 将父线程的ThreadLocalMap拷贝到此线程中
 */
private ThreadLocalMap(ThreadLocalMap parentMap) {
    //父线程的ThreadLocalMap的entry数组 
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    // 这里的table就是此线程中的ThreadLocalMap的entry数组 
    table = new Entry[len];

    // 循环进行拷贝 parentMap 的记录
    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) {
                //这里被InheritableThreadLocal重写，直接返回value，不做任何操作
                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++;
            }
        }
    }
}