flowchart TD
    subgraph 三驾马车
        REF[反射\n运行时获取类的信息\n调用方法和字段]
        PROXY[动态代理\n拦截方法调用\n注入横切逻辑]
        ANN[注解\n声明式标记\n元数据描述]
    end

    REF -->|Spring IoC: 扫描 + 实例化| SP[Spring]
    REF -->|MyBatis: Mapper 代理实现| MB

    PROXY -->|Spring AOP: 事务、缓存、安全| SP
    PROXY -->|MyBatis: Mapper 接口代理| MB

    ANN -->|Spring: @Service, @Autowired| SP
    ANN -->|MyBatis: @Select, @Param| MB

    SP -->|最终组成| APP[你的应用]
    MB --> APP

    style REF fill:#3498db,color:#fff
    style PROXY fill:#e74c3c,color:#fff
    style ANN fill:#27ae60,color:#fff

public class ReflectionCore {

    // 能力 1：运行时获取类的元信息
    public void getClassInfo() throws Exception {
        // 三种获取 Class 对象的方式
        Class clazz1 = Class.forName("com.example.User");
        Class clazz2 = User.class;
        Class clazz3 = new User().getClass();

        // 获取所有信息
        Field[] fields = clazz1.getDeclaredFields();  // 所有字段
        Method[] methods = clazz1.getDeclaredMethods(); // 所有方法
        Constructor[] constructors = clazz1.getDeclaredConstructors(); // 构造器
        Annotation[] annotations = clazz1.getAnnotations(); // 注解

        System.out.println("Fields: " + Arrays.toString(fields));
        System.out.println("Methods: " + Arrays.toString(methods));
    }

    // 能力 2：运行时创建对象
    public void createObject() throws Exception {
        // 方式一：Class 对象调用
        Class clazz = Class.forName("com.example.User");
        User user1 = (User) clazz.getDeclaredConstructor().newInstance();

        // 方式二：指定参数构造器
        Constructor<User> constructor = clazz.getConstructor(String.class, int.class);
        User user2 = constructor.newInstance("Alice", 25);
    }

    // 能力 3：运行时调用方法和访问字段
    public void invokeMethodAndField() throws Exception {
        User user = new User("Bob", 30);
        Class clazz = user.getClass();

        // 调用方法
        Method setNameMethod = clazz.getMethod("setName", String.class);
        setNameMethod.invoke(user, "Charlie");

        // 访问私有字段
        Field nameField = clazz.getDeclaredField("name");
        nameField.setAccessible(true);  // 突破 private 限制
        String name = (String) nameField.get(user);

        // 调用私有方法
        Method privateMethod = clazz.getDeclaredMethod("privateMethod");
        privateMethod.setAccessible(true);
        privateMethod.invoke(user);
    }
}

public class AccessibleDemo {

    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("java.lang.String");

        // 访问 String 的私有字段 value
        Field valueField = clazz.getDeclaredField("value");
        valueField.setAccessible(true);  // 没有这行会报 IllegalAccessException

        String str = "Hello";
        byte[] value = (byte[]) valueField.get(str);
        System.out.println("String value: " + Arrays.toString(value));

        // 修改字符串内容（JDK 9+ value 类型为 byte[]）
        value[0] = 'h';  // "Hello" → "hello"
        System.out.println(str);  // 输出 "hello"！
    }
}

// 反射调用的优化方法

// 方法 1：缓存 Method 对象（避免重复反射查找）
public class MethodCache {
    private final Map<Class, Map<String, Method>> methodCache = new ConcurrentHashMap<>();

    public Object invokeMethod(Object target, String methodName, Object... args) {
        Class clazz = target.getClass();

        // 从缓存中获取 Method
        Method method = methodCache
            .computeIfAbsent(clazz, c -> new ConcurrentHashMap<>())
            .computeIfAbsent(methodName, name -> {
                try {
                    Method m = clazz.getDeclaredMethod(name);
                    m.setAccessible(true);
                    return m;
                } catch (NoSuchMethodException e) {
                    throw new RuntimeException(e);
                }
            });

        return method.invoke(target, args);
    }
}

// 方法 2：使用 MethodHandle（Java 7+）
// MethodHandle 比反射快，因为它更接近方法的内部表示
public class MethodHandleDemo {

    public void demo() throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType mt = MethodType.methodType(String.class, String.class);

        // 查找 String.replace 的 MethodHandle
        MethodHandle mh = lookup.findVirtual(String.class, "replace", mt);

        // 绑定参数并调用
        String result = (String) mh.invoke("Hello World", "World", "Java");
        System.out.println(result);  // "Hello Java"
    }
}

// 方法 3：使用 LambdaMetafactory（Java 8+）
// 将反射调用转换为函数式接口，性能接近直接调用
public class LambdaFactoryDemo {

    @FunctionalInterface
    interface UserNameGetter {
        String getName(User user);
    }

    public UserNameGetter createGetter() throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodHandle getter = lookup.findVirtual(User.class, "getName", 
            MethodType.methodType(String.class));

        // 将 MethodHandle 转换为函数式接口
        CallSite site = LambdaMetafactory.metafactory(
            lookup, "getName", MethodType.methodType(UserNameGetter.class),
            MethodType.methodType(String.class, User.class),  // 签名
            getter, getter.type());

        return (UserNameGetter) site.getTarget().invokeExact();
    }
}

// Spring 的 Bean 实例化
public class SpringIoCSimulator {

    public Object createBean(Class clazz) {
        try {
            // 1. 查找无参构造器
            Constructor constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(true);

            // 2. 实例化
            Object bean = constructor.newInstance();

            // 3. 处理 @Autowired 字段注入
            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    Object dependency = getBean(field.getType());  // 从 IoC 容器获取
                    field.set(bean, dependency);
                }
            }

            // 4. 处理 @PostConstruct 初始化方法
            for (Method method : clazz.getDeclaredMethods()) {
                if (method.isAnnotationPresent(PostConstruct.class)) {
                    method.setAccessible(true);
                    method.invoke(bean);
                }
            }

            return bean;
        } catch (Exception e) {
            throw new RuntimeException("Failed to create bean: " + clazz, e);
        }
    }
}

// JDK 动态代理：只能代理接口

// 第一步：定义接口
public interface UserService {
    User findById(Long id);
    void save(User user);
}

// 第二步：实现类
public class UserServiceImpl implements UserService {
    @Override
    public User findById(Long id) {
        System.out.println("Executing findById: " + id);
        return new User();
    }

    @Override
    public void save(User user) {
        System.out.println("Executing save: " + user);
    }
}

// 第三步：InvocationHandler
public class LoggingHandler implements InvocationHandler {

    private final Object target;

    public LoggingHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.nanoTime();

        try {
            // 前置增强
            System.out.println("Before: " + method.getName());

            // 调用实际方法
            Object result = method.invoke(target, args);

            return result;
        } finally {
            // 后置增强
            long elapsed = System.nanoTime() - start;
            System.out.println("After: " + method.getName() + " took " + elapsed + "ns");
        }
    }
}

// 第四步：创建代理对象并使用
public class ProxyDemo {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();

        // 创建代理
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LoggingHandler(target)
        );

        // 调用代理方法
        proxy.findById(1L);
        proxy.save(new User());

        // 验证代理类型
        System.out.println("Is proxy: " + Proxy.isProxyClass(proxy.getClass()));

        // 获取 InvocationHandler
        InvocationHandler handler = Proxy.getInvocationHandler(proxy);
        System.out.println("Handler: " + handler.getClass().getName());
    }
}

// $Proxy0 类的内部结构（简化）
public class $Proxy0 extends Proxy implements UserService {

    // 缓存 Method 对象（优化反射性能）
    private static Method m1 = ...;  // equals
    private static Method m2 = ...;  // toString
    private static Method m3 = ...;  // findById
    private static Method m4 = ...;  // save
    private static Method m5 = ...;  // hashCode

    public $Proxy0(InvocationHandler h) {
        super(h);
    }

    @Override
    public User findById(Long id) {
        try {
            return (User) super.h.invoke(this, m3, new Object[]{id});
        } catch (RuntimeException | Error e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    @Override
    public void save(User user) {
        try {
            super.h.invoke(this, m4, new Object[]{user});
        } catch (RuntimeException | Error e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }
}

// CGLIB 代理：通过生成子类来实现

// 被代理的类——没有实现任何接口
public class UserServiceSimple {
    public User findById(Long id) {
        System.out.println("Finding user: " + id);
        return new User();
    }

    // final 方法不会被代理！
    public final String getVersion() {
        return "1.0";
    }
}

// CGLIB MethodInterceptor
public class CglibProxyDemo {
    public static void main(String[] args) {
        // 使用 CGLIB 的 Enhancer
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserServiceSimple.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, args1, proxy) -> {
            long start = System.nanoTime();
            try {
                System.out.println("CGLIB Before: " + method.getName());
                // 调用父类的原始方法
                Object result = proxy.invokeSuper(obj, args1);
                return result;
            } finally {
                System.out.println("CGLIB After: " + method.getName() 
                    + " took " + (System.nanoTime() - start) + "ns");
            }
        });

        // 创建代理对象
        UserServiceSimple proxy = (UserServiceSimple) enhancer.create();
        proxy.findById(1L);

        // final 方法不会被代理
        proxy.getVersion();  // 直接调用，没有拦截
    }
}

// Spring 是如何实现 @Transactional 的？
// 答案：通过动态代理！

@Configuration
@EnableTransactionManagement
public class AppConfig {

    // 当调用 service.save() 时，实际调用的是代理对象
    // 代理对象在 save() 前后插入事务逻辑
    @Transactional
    @Service
    public class UserService {
        public void save(User user) {
            jdbcTemplate.update("INSERT INTO user...");
        }
    }
}

// 代理对象的行为类似：
// proxy.save(user) {
//     beginTransaction();
//     try {
//         target.save(user);  // 实际方法调用
//         commitTransaction();
//     } catch (Exception e) {
//         rollbackTransaction();
//         throw e;
//     }
// }

// MyBatis 使用 JDK 动态代理创建 Mapper 接口的代理对象
// UserMapper proxy = (UserMapper) Proxy.newProxyInstance(
//     classLoader, interfaces, sqlSessionProxyHandler);

// 当调用 proxy.findById(1L) 时
// MapperProxy.invoke() 做了以下事：
// 1. 根据 Method 查找对应的 MappedStatement
// 2. 从 Method 的参数注解中获取 @Param 值
// 3. 调用 SqlSession.selectOne("namespace.findById", params)
// 4. 返回结果

// 自定义注解示例
@Retention(RetentionPolicy.RUNTIME)  // 运行时保留（反射可读）
@Target(ElementType.METHOD)          // 应用于方法
@Documented
public @interface AuditLog {

    // 注解属性——如果只定义一个属性，建议命名为 value
    String action();                   // 必须提供
    String module() default "";       // 有默认值
    int priority() default 5;         // 基本类型
    Level level() default Level.INFO; // 枚举类型
    Class exceptionHandler() default DefaultHandler.class; // 类类型

    enum Level { INFO, WARN, ERROR }
}

flowchart LR
    subgraph 编译期
        A[Java 源码\n@Data\nclass User] -->|javac 编译| B[Lombok Annotation Processor\n插入 getter/setter]
        B --> C[生成的 .class 文件\n包含 getter/setter 方法]
    end

    subgraph 运行期
        C -->|JVM 加载| D[运行中的 User 类\n拥有完整方法]
    end

// 运行时注解的处理——框架的核心能力

// 定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NotNull {
    String message() default "参数不能为空";
}

// 使用注解
public class OrderService {

    @NotNull(message = "订单 ID 不能为空")
    public Order findById(Long orderId) {
        // 业务逻辑
        return new Order();
    }

    @NotNull
    @AuditLog(action = "CREATE_ORDER", module = "ORDER")
    public void createOrder(Order order) {
        // 业务逻辑
    }
}

// 注解处理器
public class AnnotationProcessor {

    public void processAnnotations(Object bean) {
        Class clazz = bean.getClass();

        // 遍历所有方法
        for (Method method : clazz.getDeclaredMethods()) {

            // 读取 @AuditLog 注解
            AuditLog auditLog = method.getAnnotation(AuditLog.class);
            if (auditLog != null) {
                System.out.println("Audit: action=" + auditLog.action() 
                    + ", module=" + auditLog.module());
            }

            // 读取 @NotNull 注解
            NotNull notNull = method.getAnnotation(NotNull.class);
            if (notNull != null) {
                // 验证方法参数
                for (Parameter param : method.getParameters()) {
                    if (param.getAnnotation(NotNull.class) != null) {
                        System.out.println("Parameter " + param.getName() 
                            + " must not be null: " + notNull.message());
                    }
                }
            }

            // 读取方法上所有注解
            Annotation[] allAnnotations = method.getAnnotations();
            for (Annotation ann : allAnnotations) {
                System.out.println("Method " + method.getName() 
                    + " has annotation: " + ann.annotationType().getSimpleName());
            }
        }

        // 遍历所有字段
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Autowired.class)) {
                System.out.println("Field " + field.getName() 
                    + " needs injection");
            }
        }
    }
}

// 注解的"继承"——使用 @AliasFor 实现注解组合

// Spring 的 @AliasFor 注解示例：

// Spring 将 @GetMapping 定义为 @RequestMapping 的别名
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {

    @AliasFor(annotation = RequestMapping.class, attribute = "path")
    String[] value() default {};

    @AliasFor(annotation = RequestMapping.class, attribute = "path")
    String[] path() default {};

    // 自动继承 RequestMapping 的其他属性
    // method 已经被固定为 GET
}

// 使用组合注解的好处：
@GetMapping("/user")         // 等价于 @RequestMapping(path="/user", method=GET)
public List<User> list() {   // 更简洁！
    return userService.findAll();
}

// 1. 定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Cached {
    String key() default "";
    long ttl() default 30000;  // 毫秒
}

// 2. 实现注解处理器 + 动态代理
public class CacheProxyFactory {

    private final Map<String, Object> cacheMap = new ConcurrentHashMap<>();

    @SuppressWarnings("unchecked")
    public <T> T createProxy(T target) {
        Class clazz = target.getClass();

        // 使用 JDK 代理或 CGLIB
        if (clazz.getInterfaces().length > 0) {
            return (T) Proxy.newProxyInstance(
                clazz.getClassLoader(),
                clazz.getInterfaces(),
                new CacheInvocationHandler(target)
            );
        } else {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(clazz);
            enhancer.setCallback(new CacheMethodInterceptor(target));
            return (T) enhancer.create();
        }
    }

    // JDK 代理实现
    private class CacheInvocationHandler implements InvocationHandler {
        private final Object target;

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 通过反射读取 @Cached 注解
            Cached cached = method.getAnnotation(Cached.class);

            if (cached != null) {
                String cacheKey = buildCacheKey(method, args, cached);

                // 查询缓存
                Object cachedResult = cacheMap.get(cacheKey);
                if (cachedResult != null) {
                    System.out.println("Cache HIT: " + cacheKey);
                    return cachedResult;
                }

                // 通过反射调用实际方法
                Object result = method.invoke(target, args);

                // 存入缓存
                cacheMap.put(cacheKey, result);
                System.out.println("Cache MISS: " + cacheKey);
                return result;
            }

            // 没有 @Cached 注解，直接调用
            return method.invoke(target, args);
        }

        private String buildCacheKey(Method method, Object[] args, Cached cached) {
            if (!cached.key().isEmpty()) {
                return cached.key();
            }
            // 默认：类名.方法名(参数)
            return target.getClass().getSimpleName() + "." 
                 + method.getName() + "(" + Arrays.toString(args) + ")";
        }
    }

    // 使用示例
    public static void main(String[] args) {
        UserService service = new UserServiceImpl();
        UserService proxy = new CacheProxyFactory().createProxy(service);

        // 第一次调用：缓存 MISS，执行实际方法
        proxy.findById(1L);

        // 第二次调用：缓存 HIT，跳过实际方法
        proxy.findById(1L);
    }
}

flowchart LR
    subgraph JDK 演进
        JDK5[JDK 5-7] -->|分段锁 Segment| CHM7[ConcurrentHashMap v1]
        JDK8[JDK 8+] -->|CAS + synchronized| CHM8[ConcurrentHashMap v2]
        JDK21[JDK 21] -->|新增| CHM21[ConcurrentHashMap v3\n细粒度优化]
    end

    CHM7 -->|特点| P1[ConcurrencyLevel 控制分段数]
    CHM7 -->|问题| P2[分段大小固定, 碎片化]
    CHM8 -->|特点| P3[桶粒度锁, 无分段]
    CHM8 -->|优势| P4[更低的内存占用, 更高的并发度]

// JDK 7 ConcurrentHashMap 的核心结构

// Segment 继承 ReentrantLock，每个 Segment 保护一个 HashEntry 数组
// 可以理解为"一个 ConcurrentHashMap 由多个小 HashMap 组成"
public class ConcurrentHashMap<K, V> {
    // Segment 数组（默认 16）
    final Segment<K,V>[] segments;

    // 默认并发级别
    static final int DEFAULT_CONCURRENCY_LEVEL = 16;

    // 一个 Segment 就是一个小的哈希表
    static final class Segment<K,V> extends ReentrantLock {
        transient volatile HashEntry<K,V>[] table;
        transient int count;
        transient int modCount;
        transient int threshold;
        final float loadFactor;
    }

    // 实际的键值对节点
    static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;
    }
}

public class ConcurrentHashMap<K,V> {
    // 最大的表容量
    private static final int MAXIMUM_CAPACITY = 1 << 30;

    // 默认初始容量
    private static final int DEFAULT_CAPACITY = 16;

    // 并发级别——不再是分段数，而是用于计算容量
    // 对齐到 2 的幂，且 >= 16
    private static final int DEFAULT_CONCURRENCY_LEVEL = 16;

    // 负载因子——仅是用于构造函数兼容，实际计算已不使用
    private static final float LOAD_FACTOR = 0.75f;

    // 链表转红黑树的阈值
    static final int TREEIFY_THRESHOLD = 8;

    // 红黑树转链表的阈值
    static final int UNTREEIFY_THRESHOLD = 6;

    // 转红黑树的最小表容量（避免容量很小时就转树）
    static final int MIN_TREEIFY_CAPACITY = 64;

    // 核心数组——volatile 保证可见性
    transient volatile Node<K,V>[] table;

    // 扩容时使用的新数组
    private transient volatile Node<K,V>[] nextTable;

    // 扩容进度标识
    // -1：正在初始化
    // -(1 + 正在扩容的线程数)：有线程在扩容
    // 正数：下一次扩容的阈值
    private transient volatile int sizeCtl;
}

// 普通节点
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;       // volatile 保证可见性
    volatile Node<K,V> next;  // volatile 保证可见性

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }
}

// 红黑树节点
static final class TreeNode<K,V> extends Node<K,V> {
    TreeNode<K,V> parent;
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    TreeNode<K,V> prev;
    boolean red;
}

// TreeBin——红黑树的容器（持有根节点）
// 负责写时加锁、读时无锁（通过 volatile 和 CAS 保证安全）
static final class TreeBin<K,V> extends Node<K,V> {
    TreeNode<K,V> root;
    volatile TreeNode<K,V> first;
    volatile Thread waiter;  // 等待写锁的线程
    volatile int lockState;
    // 读锁计数器
    static final int WRITER = 1;
    static final int WAITER = 2;
    static final int READER = 4;
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();

    int hash = spread(key.hashCode());  // 让高 16 位也参与散列
    int binCount = 0;

    // 自旋——直到操作成功
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;

        // 第一步：延迟初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();  // CAS 保证只有一个线程初始化

        // 第二步：当前桶为空 → CAS 直接放入
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;  // CAS 成功 → 完成
            // CAS 失败 → 自旋重试
        }

        // 第三步：正在扩容 → 帮忙扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);

        // 第四步：发生冲突 → synchronized 桶的头节点
        else {
            V oldVal = null;
            synchronized (f) {  // 只锁这一个桶！
                if (tabAt(tab, i) == f) {  // 双重检查
                    if (fh >= 0) {
                        // 链表处理
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        // 红黑树处理
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }

            // 第五步：检查是否需要树化
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 第六步：增加计数，可能触发扩容
    addCount(1L, binCount);
    return null;
}

flowchart TD
    A[putVal 开始] --> B{table 已初始化?}
    B -->|否| C[initTable\nCAS 初始化]
    B -->|是| D{目标桶为空?}
    C --> D

    D -->|是| E[CAS 放入节点\n成功即退出]
    D -->|否| F{桶头 hash == MOVED?}

    E -->|CAS 失败| D
    F -->|是| G[helpTransfer\n帮忙扩容]
    F -->|否| H[synchronized(f)\n只锁这个桶]

    H --> I{链表还是红黑树?}
    I -->|链表| J[遍历链表\n替换或插入]
    I -->|红黑树| K[TreeBin.putTreeVal]

    J --> L{节点数 >= 8?}
    L -->|是| M[treeifyBin\n转为红黑树]
    L -->|否| N[完成 put]
    M --> N
    K --> N

    N --> O[addCount\n增加元素计数]
    O --> P{需要扩容?}
    P -->|是| Q[transfer\n触发扩容]
    P -->|否| R[返回]

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;

    int h = spread(key.hashCode());

    // 第一步：table 非空且对应桶非空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {

        // 第二步：检查桶头节点
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;  // 桶头就是目标
        }

        // 第三步：hash < 0 表示是特殊节点
        // （红黑树、ForwardingNode、ReservationNode）
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;

        // 第四步：遍历链表
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;

    // 计算每个线程负责的桶数（stride）
    // 最小 16，确保每个线程至少处理 16 个桶
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE;

    // 初始化 nextTab（第一个进来的线程负责创建）
    if (nextTab == null) {
        try {
            // 新容量 = 旧容量 * 2
            Node<K,V>[] nt = (Node<K,V>[])new Node,?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        nextTable = nextTab;
        transferIndex = n;  // 从末尾开始分配
    }

    int nextn = nextTab.length;
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    boolean advance = true;
    boolean finishing = false;

    // 循环处理每个桶的迁移
    for (int i = 0, bound = 0;;) {
        Node<K,V> f; int fh;

        // ... 从 transferIndex 分配要处理的桶范围 ...

        // 迁移单个桶的链表/红黑树
        synchronized (f) {
            // 链表拆分为低位链表和高位链表
            // 因为扩容后 hash 索引取决于新的一位 bit
            // 低位链表: 索引不变
            // 高位链表: 索引 + oldCap

            // 使用反向链表插入（类似 JDK 7 的建表方式）
            // 但在扩容完后会修复链表顺序——通过 check 机制
        }
    }
}

flowchart TD
    subgraph 扩容前
        B0[桶 0]
        B1[桶 1]
        B2[桶 2]
        B3[桶 3]
        B4[...]
    end

    subgraph 多线程扩容
        T1[线程 1\n负责桶 0-100]
        T2[线程 2\n负责桶 101-200]
        T3[线程 3\n负责桶 201-300]
    end

    subgraph 扩容后
        NB0[新桶 0]
        NB1[新桶 1]
        NB2[新桶 2]
        NB3[...]
    end

    T1 -->|迁移| NB0
    T1 -->|迁移| NB1
    B0 --> T1
    B1 --> T1
    B2 --> T2
    B3 --> T3

    ForwardingNode -->|get 操作遇到\n转发到新表| NB0

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
            // 其他线程正在初始化 → 让出 CPU
            Thread.yield();
        else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
            // CAS 抢到了初始化权
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);  // 0.75 * n
                }
            } finally {
                sizeCtl = sc;  // 恢复为扩容阈值
            }
            break;
        }
    }
    return tab;
}

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;

    // 使用 CounterCell 做计数累加（类似 LongAdder）
    // 避免高并发下的 CAS 竞争
    if ((as = counterCells) != null ||
        !U.compareAndSetLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        // CAS 失败 → 使用 CounterCell 分片计数
        // ...
    }

    // 检查是否需要扩容
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);

            if (sc < 0) {
                // 正在扩容 → 尝试加入
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // 自己触发扩容
            else if (U.compareAndSetInt(this, SIZECTL, sc,
                     (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}

final long sumCount() {
    CounterCell[] as = counterCells;
    CounterCell a;
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

// CounterCell 的设计：分段累加，减少 CAS 冲突
@sun.misc.Contended  // 避免伪共享（False Sharing）
static final class CounterCell {
    volatile long value;
    CounterCell(long x) { value = x; }
}

// ❌ 反例：依赖 size() 做精确判断
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// 线程 A：map.put("key", 1);
// 线程 B：map.size(); // 可能返回 0（看不到线程 A 的 put）
// ConcurrentHashMap 的 size() 是近似值，不是实时精确的

// ✅ 正例：使用 atomic 操作
map.compute("key", (k, v) -> v == null ? 1 : v + 1);

// computeIfAbsent 有一个"经典陷阱"
// 它的文档说：如果计算函数抛异常，会删除插入的映射
// 但在某些并发场景下，可能会出现"幽灵值"问题

// ✅ 正例：使用 putIfAbsent 替代
String existing = map.putIfAbsent(key, "value");
if (existing != null) {
    // 已经有值了
}

// 或者使用 computeIfAbsent 但确保函数是幂等的
map.computeIfAbsent("key", k -> {
    // 这个函数只会执行一次（由 CAS 保证）
    // 但如果执行次数超出预期，结果也一样
    return heavyCompute(k);
});

// ConcurrentHashMap 的迭代器（Iterator/Spliterator）是弱一致性的：
// 1. 遍历时看到的元素是遍历开始时刻的快照（近似）
// 2. 遍历过程中新增的元素可能看到也可能看不到
// 3. 不会抛出 ConcurrentModificationException

// 这意味着不能依赖遍历做精确的业务逻辑判断
// 但相对于加锁遍历，性能优势巨大

// ❌ 反例：不指定初始容量
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
// 默认容量 16，如果预期存储 10 万条数据
// 会触发多次扩容（16→32→64→...→131072）
// 每次扩容都是全表迁移

// ✅ 正例：指定合理的初始容量
// 计算公式：expectedSize / 0.75 + 1
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>(100_000);
// 实际容量 = 131072（2 的幂，接近 100000/0.75 ≈ 133333）

flowchart TD
    subgraph 设计哲学
        CA[使用 CAS 处理\n大多数无冲突情况]
        SY[使用 synchronized\n处理少量冲突]
        VO[使用 volatile\n保证可见性]
        MU[多线程协作\n处理扩容]
        CO[CounterCell\n分片计数]
    end

    CA -->|优势| P1[无锁路径延迟最低]
    SY -->|优势| P2[桶级粒度,极细]
    VO -->|优势| P3[读操作不需要锁]
    MU -->|优势| P4[扩容不阻塞写操作]
    CO -->|优势| P5[高并发下计数不成为瓶颈]

# JVM 参数配置
-Xms4g                    # 初始堆大小
-Xmx4g                    # 最大堆大小
-Xmn2g                    # 年轻代大小
-XX:MetaspaceSize=256m    # 元空间初始大小
-XX:MaxMetaspaceSize=256m # 元空间最大大小
-XX:+UseG1GC              # 使用 G1 垃圾回收器
-XX:MaxGCPauseMillis=200  # 最大 GC 停顿时间目标
-XX:InitiatingHeapOccupancyPercent=45  # 触发并发标记的堆占用百分比
-XX:+HeapDumpOnOutOfMemoryError  # OOM 时生成堆转储
-XX:HeapDumpPath=/var/log/app/heapdump.hprof

graph TD
    subgraph GC[GC Evolution]
        S[Serial<br/>单线程, STW] --> P[Parallel<br/>多线程, 高吞吐]
        P --> C[CMS<br/>低延迟, 有碎片]
        C --> G1[G1<br/>平衡延迟与吞吐]
        G1 --> Z[ZGC<br/>亚毫秒级停顿<br/>&lt;10ms]
    end

# G1 GC 日志参数
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-XX:+PrintGCTimeStamps
-XX:+PrintAdaptiveSizePolicy
-Xloggc:/var/log/app/gc.log

2026-05-16T10:30:00.123+0800: [GC pause (G1 Evacuation Pause) (young)
Desired survivor size 30502912 bytes, new threshold 6 (max threshold 15)
- age   1:    1677824 bytes,    1677824 total
- age   2:     524288 bytes,    2202112 total
]
  [Parallel Time: 45.2 ms, GC Workers: 8]
  [Ext Root Scanning (ms): 1.2]
  [Update RS (ms): 3.8]
  [Processed Buffers: 32]
  [Scan RS (ms): 2.1]
  [Code Root Scanning (ms): 0.5]
  [Object Copy (ms): 35.6]
  [Termination (ms): 1.5]
  [GC Worker Other (ms): 0.5]
  [Clear CT (ms): 0.3]
  [Other: 0.8 ms]
  [Eden: 512.0M(512.0M)->0.0B(512.0M) Survivors: 64.0M->64.0M Heap: 1.2G(4.0G)->712.0M(4.0G)]
  [Times: user=0.32 sys=0.04, real=0.05 secs]