import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 使用ThreadLocal模拟数据库连接池的测试方法
 */
public class ThreadLocalTest {
    // 模拟数据库连接对象
    static class Connection {
        // 数据库连接ID
        private final String connectionId;

        public Connection(String connectionId) {
            this.connectionId = connectionId;
        }

        public String getConnectionId() {
            return connectionId;
        }
    }

    // 模拟数据库连接池
    static class ConnectionPool {
        // 使用ThreadLocal存储数据库连接
        private static final ThreadLocal<Connection> threadLocalConnection = ThreadLocal.withInitial(() -> new Connection("Connection-1"));

        // 获取数据库连接
        public static Connection getConnection() {
            return threadLocalConnection.get();
        }

        // 归还数据库连接（这里简化为清除ThreadLocal中的连接）
        public static void releaseConnection() {
            threadLocalConnection.remove();
        }
    }

    // 模拟公共数据集
    static class SharedDataSet {
        // 使用ThreadLocal存储数据集
        private static final ThreadLocal<String> threadLocalDataSet = new ThreadLocal<>();

        // 设置数据集
        public static void setDataSet(String dataSet) {
            threadLocalDataSet.set(dataSet);
        }

        // 获取数据集
        public static String getDataSet() {
            return threadLocalDataSet.get();
        }

        // 清除数据集
        public static void clearDataSet() {
            threadLocalDataSet.remove();
        }
    }

    // 模拟数据库查询任务
    static class DatabaseQueryTask implements Runnable {
        @Override
        public void run() {
            // 从连接池获取数据库连接
            Connection connection = ConnectionPool.getConnection();
            System.out.println("线程 " + Thread.currentThread().getName() + " 使用连接进行查询: " + connection.getConnectionId());

            // 模拟数据库查询
            try {
                System.out.println("线程 " + Thread.currentThread().getName() + " 开始模拟数据库查询...");
                Thread.sleep(1000);
                System.out.println("线程 " + Thread.currentThread().getName() + " 完成模拟数据库查询！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 获取数据集并输出
            String dataSet = SharedDataSet.getDataSet();
            System.out.println("线程 " + Thread.currentThread().getName() + " 获取数据集: " + dataSet);

            // 设置数据集并输出
            SharedDataSet.setDataSet("Data from " + Thread.currentThread().getName());
            System.out.println("线程 " + Thread.currentThread().getName() + " 设置数据集: Data from " + Thread.currentThread().getName());

            // 归还数据库连接
            ConnectionPool.releaseConnection();
            System.out.println("线程 " + Thread.currentThread().getName() + " 归还连接: " + connection.getConnectionId());
        }
    }

    public static void main(String[] args) {
        // 创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 提交多个数据库查询任务
        for (int i = 0; i < 10; i++) {
            executorService.submit(new DatabaseQueryTask());
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

public class ThreadLocalMap {

    // Entry 类表示 ThreadLocal 实例与局部变量值之间的映射关系
    static class Entry {
        final ThreadLocal<?> key; // ThreadLocal 实例
        Object value; // 局部变量值

        Entry(ThreadLocal<?> k, Object v) {
            key = k;
            value = v;
        }
    }

    private Entry[] table; // Entry 数组

    // 构造函数，初始化 Entry 数组
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        table = new Entry[16];
        int index = firstKey.threadLocalHashCode & (table.length - 1);
        table[index] = new Entry(firstKey, firstValue);
    }

    // 根据 ThreadLocal 获取对应的 Entry
    Entry getEntry(ThreadLocal<?> key) {
        int index = key.threadLocalHashCode & (table.length - 1);
        return table[index];
    }

    // 设置 ThreadLocal 对应的局部变量值
    void set(ThreadLocal<?> key, Object value) {
        int index = key.threadLocalHashCode & (table.length - 1);
        table[index] = new Entry(key, value);
    }
}

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();
}

// ThreadContextManager.java
public class ThreadContextManager {
    // 使用ThreadLocal存储用户名
    private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();

    // 设置当前线程的用户名
    public static void setUserName(String userName) {
        threadLocal.set(userName);
    }

    // 获取当前线程的用户名
    public static String getUserName() {
        return threadLocal.get();
    }

    public static void main(String[] args) {
        // 创建两个线程，并分别设置不同的用户名
        Thread thread1 = new Thread(() -> {
            ThreadContextManager.setUserName("User1");
            System.out.println("Thread1: User name is " + ThreadContextManager.getUserName());
        });

        Thread thread2 = new Thread(() -> {
            ThreadContextManager.setUserName("User2");
            System.out.println("Thread2: User name is " + ThreadContextManager.getUserName());
        });

        // 启动线程
        thread1.start();
        thread2.start();

        // 等待线程执行结束
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 在主线程中获取用户名
        System.out.println("Main thread: User name is " + ThreadContextManager.getUserName());

        // 在主线程中设置新的用户名
        ThreadContextManager.setUserName("NewUser");

        // 再次获取用户名，确保设置成功
        System.out.println("Main thread: User name is " + ThreadContextManager.getUserName());
    }
}

public class DatabaseConnectionManager {
    private static final ThreadLocal<Connection> connectionHolder = 
                            ThreadLocal.withInitial(() -> createConnection());

    private static Connection createConnection() {
        // 实现创建数据库连接的逻辑
    }

    public static Connection getConnection() {
        return connectionHolder.get();
    }
}

/**
 * 在一个基于Web的应用程序中，每个HTTP请求都是一个独立的线程。
 * 为了在请求处理过程中共享会话信息，可以使用ThreadLocal来存储当前用户的会话信息。
 */
public class SessionManager {
    // 使用ThreadLocal存储当前线程的用户会话信息
    private static final ThreadLocal<UserSession> userSessionThreadLocal = new ThreadLocal<>();

    /**
     * 设置当前线程的用户会话信息。
     *
     * @param userSession 当前线程的用户会话信息
     */
    public static void setUserSession(UserSession userSession) {
        userSessionThreadLocal.set(userSession);
    }

    /**
     * 获取当前线程的用户会话信息。
     *
     * @return 当前线程的用户会话信息
     */
    public static UserSession getUserSession() {
        return userSessionThreadLocal.get();
    }
}