public class ThreadLocalMultiThreadTest {
    private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        // 線程1：存入值
        new Thread(() -> {
            threadLocal.set("線程1的變量副本");
            System.out.println("線程1取值：" + threadLocal.get()); // 正常輸出：線程1的變量副本
        }).start();

        // 線程2：嘗試取值（未存入）
        new Thread(() -> {
            System.out.println("線程2取值：" + threadLocal.get()); // 輸出：null
        }).start();
    }
}

import org.apache.commons.io.IOUtils;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.function.Supplier;

public class StaticClassLoaderTest implements Supplier<Integer> {

    // 靜態(tài)ThreadLocal變量（類加載器不同時，會產(chǎn)生多個該變量實例）
    protected static final ThreadLocal<Integer> local = new ThreadLocal<Integer>();

    public StaticClassLoaderTest() {
    }

    // 存入值：向當(dāng)前線程的ThreadLocalMap中存入local（當(dāng)前類加載器對應(yīng)的實例）和值
    public void setInfo(Integer val) {
        local.set(val);
        System.out.println("set成功，當(dāng)前類加載器：" + this.getClass().getClassLoader());
    }

    public static void main(String[] args) {
        try {
            // 1. 使用系統(tǒng)類加載器（AppClassLoader）加載當(dāng)前類，創(chuàng)建實例并存入值
            StaticClassLoaderTest supplier1 = new StaticClassLoaderTest();
            supplier1.setInfo(2); // 此時存入的是「AppClassLoader加載的local實例」對應(yīng)的值

            // 2. 使用自定義類加載器（cusLoader）加載當(dāng)前類，創(chuàng)建實例并嘗試取值
            // 自定義類加載器加載的StaticClassLoaderTest，與系統(tǒng)類加載器加載的是不同的Class對象
            Supplier<Integer> staticClassLoaderTest2 = (Supplier<Integer>) 
                    Class.forName("gittest.StaticClassLoaderTest", true, new CusLoader())
                          .newInstance();
            
            // 取值失?。簊taticClassLoaderTest2的local是「CusLoader加載的local實例」，與supplier1的local不是同一個對象
            System.out.println("自定義類加載器取值：" + staticClassLoaderTest2.get()); // 輸出：null

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 自定義類加載器：重寫loadClass方法，優(yōu)先加載指定類
    public static class CusLoader extends ClassLoader {
        @Override
        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
            // 只攔截當(dāng)前類的加載
            if (name.contains("StaticClassLoaderTest")) {
                // 從類路徑中獲取class文件的輸入流
                InputStream is = Thread.currentThread().getContextClassLoader()
                        .getResourceAsStream(name.replace(".", "/") + ".class");
                ByteArrayOutputStream output = new ByteArrayOutputStream();
                try {
                    // 讀取class文件內(nèi)容
                    IOUtils.copy(is, output);
                    // 定義Class對象（自定義類加載器加載）
                    return defineClass(name, output.toByteArray(), 0, output.toByteArray().length);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 其他類仍使用父類加載器加載（遵循雙親委派模型）
            return super.loadClass(name, resolve);
        }
    }

    // 取值方法：從當(dāng)前線程的ThreadLocalMap中獲取local對應(yīng)的值
    @Override
    public Integer get() {
        System.out.println("get操作，當(dāng)前類加載器：" + this.getClass().getClassLoader());
        return StaticClassLoaderTest.local.get();
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

// 啟動類：必須添加@EnableAsync，開啟Spring異步功能
@SpringBootApplication
@EnableAsync
public class AsyncThreadLocalTest {
    public static void main(String[] args) {
        SpringApplication.run(AsyncThreadLocalTest.class, args);
    }

    // ThreadLocal工具類：模擬存儲父線程（請求線程）的上下文數(shù)據(jù)
    public static class ThreadLocalUtil {
        private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>();

        public static void setContext(String value) {
            CONTEXT.set(value);
        }

        public static String getContext() {
            return CONTEXT.get();
        }

        public static void remove() {
            CONTEXT.remove();
        }
    }

    // 異步服務(wù)類：@Async標(biāo)注的方法會在獨立線程（子線程）中執(zhí)行
    @Service
    public static class AsyncService {
        // @Async：該方法脫離父線程，在Spring默認(rèn)線程池的子線程中執(zhí)行
        @Async
        public void asyncGetContext() {
            // 子線程（異步方法）嘗試獲取父線程存入的ThreadLocal值
            String context = ThreadLocalUtil.getContext();
            System.out.println("異步方法（子線程）取值：" + context); // 輸出：null
            System.out.println("異步方法（子線程）ID：" + Thread.currentThread().getId());
        }
    }

    // 測試控制器：父線程（請求線程）存入值，調(diào)用異步方法
    @RestController
    public static class TestController {
        private final AsyncService asyncService;

        // 構(gòu)造器注入異步服務(wù)
        public TestController(AsyncService asyncService) {
            this.asyncService = asyncService;
        }

        @GetMapping("/test/async")
        public String testAsync() {
            // 父線程（請求線程）：存入值到ThreadLocal
            ThreadLocalUtil.setContext("父線程（請求線程）的上下文數(shù)據(jù)");
            System.out.println("父線程（請求線程）取值：" + ThreadLocalUtil.getContext()); // 正常輸出
            System.out.println("父線程（請求線程）ID：" + Thread.currentThread().getId());

            // 調(diào)用異步方法：觸發(fā)子線程執(zhí)行
            asyncService.asyncGetContext();

            // 清理資源，避免內(nèi)存泄漏
            ThreadLocalUtil.remove();
            return "異步請求測試完成，查看控制臺輸出";
        }
    }
}