ThreadLocal如何保证线程安全？

/**
* This class provides thread-local variables.  These variables differ from
* their normal counterparts in that each thread that accesses one (via its
* {@code get} or {@code set} method) has its own, independently initialized
* copy of the variable.  {@code ThreadLocal} instances are typically private
* static fields in classes that wish to associate state with a thread (e.g.,
* a user ID or Transaction ID).
*
* <p>For example, the class below generates unique identifiers local to each
* thread.
* A thread's id is assigned the first time it invokes {@code ThreadId.get()}
* and remains unchanged on subsequent calls.
*
* 使用样例省略...
*
* <p>Each thread holds an implicit reference to its copy of a thread-local
* variable as long as the thread is alive and the {@code ThreadLocal}
* instance is accessible; after a thread goes away, all of its copies of
* thread-local instances are subject to garbage collection (unless other
* references to these copies exist).
*
* @author  Josh Bloch and Doug Lea
* @since   1.2
  */
  public class ThreadLocal<T> {
  // 代码省略
  }

public class ThreadLocalTest {
    public static void main(String[] args) {
    // 创建一个ThreadLocal 实例
    ThreadLocal<Object> local = new ThreadLocal<>();

       // 线程1
      Thread thread1 = new Thread(() -> {
            Object object = new Object();
            local.set(object);
            System.out.println("ThreadName:" + Thread.currentThread().getName() + ",getResult:" + local.get() + ",hashCode:" + local.hashCode());
       });

        // 线程2
       Thread thread2 = new Thread(() -> {
            Object object = new Object();
            local.set(object);
            System.out.println("ThreadName:" + Thread.currentThread().getName() + ",getResult:" + local.get() + ",hashCode:" + local.hashCode());
       });

        // 线程3
       Thread thread3 = new Thread(() -> {
            Object object = new Object();
            local.set(object);
            System.out.println("ThreadName:" + Thread.currentThread().getName()+ ",getResult:" + local.get() + ",hashCode:" + local.hashCode());
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

public void set(T value) {
// 获取当前线程
Thread t = Thread.currentThread();
// 获取ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
return t.threadLocals; // 此处会跳转到java.lang.Thread中
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}

private void set(ThreadLocal<?> key, Object value) {
   Entry[] tab = table;
   int len = tab.length;
   int i = key.threadLocalHashCode & (len-1);
   // 遍历Entry数组
   for (Entry e = tab[i];
       e != null;
       e = tab[i = nextIndex(i, len)]) {
           ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
return;
}

            if (k == null) {
                replaceStaleEntry(key, value, i);
                return;
             }
        }
        tab[i] = new Entry(key, value);
        int sz = ++size;
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
           rehash();
        }

static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;

        Entry(ThreadLocal<?> k, Object v) {
           super(k); // 指向 WeakReference 的隐私引用
           value = v;
        }
}
}

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}
 Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}

public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}

org.springframework.transaction.support.TransactionSynchronizationManager(spring-5.0.7-RELEASE)
public abstract class TransactionSynchronizationManager {
private static final ThreadLocal<Map<Object, Object>> resources =
new NamedThreadLocal<>("Transactional resources");

	private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
			new NamedThreadLocal<>("Transaction synchronizations");

	private static final ThreadLocal<String> currentTransactionName =
			new NamedThreadLocal<>("Current transaction name");

	private static final ThreadLocal<Boolean> currentTransactionReadOnly =
			new NamedThreadLocal<>("Current transaction read-only status");

	private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
			new NamedThreadLocal<>("Current transaction isolation level");

	private static final ThreadLocal<Boolean> actualTransactionActive =
			new NamedThreadLocal<>("Actual transaction active");
}

package org.apache.dubbo.cache.support.threadlocal;

import java.util.HashMap;
import java.util.Map;
import org.apache.dubbo.cache.Cache;
import org.apache.dubbo.common.URL;

public class ThreadLocalCache implements Cache {
private final ThreadLocal<Map<Object, Object>> store = ThreadLocal.withInitial(HashMap::new);

    public ThreadLocalCache(URL url) {
    }

    public void put(Object key, Object value) {
        ((Map)this.store.get()).put(key, value);
    }

    public Object get(Object key) {
        return ((Map)this.store.get()).get(key);
    }
}

// 1.staleSlot 需要被删除对象在Entry[]中的位置
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;

            // expunge entry at staleSlot
            // 2.删除位置的值，因为key已经为null，所以只需要将value置为null，删除
            tab[staleSlot].value = null;
            // 3.将entry对象赋值为null
            tab[staleSlot] = null;
            // 4.Entry数组删除一个对象，size减1
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            // 5.for循坏从当前向后循坏处理Entry中的ThreadLocal对象，将遇到null
            // 之前的所有对象重hash(可以理解成数组中删除某个元素，后面所有元素需要前移动)
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                 //6.获取下一个entry
                ThreadLocal<?> k = e.get();
                // 7.key为null，说明threadLocal的弱引用已经没有了，则删除key和value
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else { // 8.key不为null，则重hash
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        // 9.从当前的位置h往后找，找到null的位置将e填入
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

public static void resolveMemoryLeaks(){
  ThreadLocal<Object> local = new ThreadLocal<>();
    for(int i = 0; i < 100; i++){
        new Thread(() -> {
        Object object = new Object();
        local.set(object);

                // 解决内存泄露
                local.remove();
            });
        }
}

public class InheritableThreadLocalTest {

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

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

    public static String msg = "hello world";

    public static void main(String[] args) throws InterruptedException {

        tl();
        itl();
    }

    public static void tl() throws InterruptedException {
        tl.set(msg);

        System.out.println("tl主线程获取的msg：" + tl.get());

        new Thread(() -> System.out.println("tl子线程获取的msg：" + tl.get())).start();

        // 线程睡眠1s
        TimeUnit.SECONDS.sleep(1L);
    }

    public static void itl() throws InterruptedException {
        itl.set(msg);

        System.out.println("itl主线程获取的msg：" + itl.get());
        new Thread(() -> System.out.println("itl子线程获取的msg：" + itl.get())).start();

        // 线程睡眠1s
        TimeUnit.SECONDS.sleep(1L);
    }
}

ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

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);
// 省略部分代码

}