Java 面试宝典

// JVM 参数配置
-XX:+UseG1GC                    // 启用 G1
-XX:MaxGCPauseMillis=200        // 最大停顿时间 200ms
-XX:G1HeapRegionSize=16m        // Region 大小
-XX:InitiatingHeapOccupancyPercent=45  // 堆占用 45% 触发并发标记

// 场景:电商系统,堆内存 8G,要求 GC 停顿 < 200ms
-Xmx8g -Xms8g
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:G1HeapRegionSize=16m
-XX:+ParallelRefProcEnabled      // 并行处理引用
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps

实测效果:
- Young GC 频率:10-20s 一次,停顿 20-50ms
- Mixed GC 频率:2-3 分钟一次,停顿 100-180ms
- Full GC:基本不发生

// 异常信息
java.lang.OutOfMemoryError: Java heap space

// 排查步骤
1. 导出堆快照
   -XX:+HeapDumpOnOutOfMemoryError
   -XX:HeapDumpPath=/tmp/heapdump.hprof

2. 使用 MAT(Memory Analyzer Tool)分析
   - 查看 Dominator Tree(支配树)
   - 定位占用内存最大的对象
   - 查看 GC Roots 引用链

// 常见原因
a) 内存泄漏:
   - ThreadLocal 未清理
   - 集合类持有大量对象
   - 监听器未注销

b) 内存不足:
   - 缓存数据过多
   - 一次性加载大量数据
   - 堆内存设置过小

// 问题代码
public class UserCache {
    private static Map<Long, User> cache = new HashMap<>();

    public void addUser(User user) {
        cache.put(user.getId(), user);  // 只增不删,内存泄漏
    }
}

// 解决方案 1:使用弱引用
private static Map<Long, WeakReference<User>> cache = new WeakHashMap<>();

// 解决方案 2:使用 Guava Cache,自动过期
LoadingCache<Long, User> cache = CacheBuilder.newBuilder()
    .maximumSize(10000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(new CacheLoader<Long, User>() {
        public User load(Long key) {
            return loadUserFromDB(key);
        }
    });

// 异常信息
java.lang.OutOfMemoryError: Metaspace

// 常见原因
1. 动态生成大量类(CGLib、Groovy、JSP)
2. 元空间设置过小

// 解决方案
-XX:MetaspaceSize=256m          // 初始元空间
-XX:MaxMetaspaceSize=512m       // 最大元空间

// 异常信息
java.lang.StackOverflowError

// 常见原因
1. 递归调用无终止条件
2. 递归深度过大

// 问题代码
public int fibonacci(int n) {
    return fibonacci(n-1) + fibonacci(n-2);  // 无终止条件
}

// 解决方案:尾递归优化或改用循环
public int fibonacci(int n) {
    if (n <= 1) return n;
    int a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        int temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

// 问题代码
public class VisibilityDemo {
    private boolean flag = false;  // 主线程写,子线程读不到

    public void write() {
        flag = true;  // CPU 缓存,未刷新到主内存
    }

    public void read() {
        while (!flag) {  // 读取 CPU 缓存,不是主内存
            // 死循环
        }
    }
}

// 解决方案 1:volatile
private volatile boolean flag = false;
// 作用:
// - 写操作立即刷新到主内存
// - 读操作从主内存读取,不走 CPU 缓存

// 解决方案 2:synchronized
public synchronized void write() {
    flag = true;
}

// 问题:i++ 不是原子操作
public class AtomicDemo {
    private int count = 0;

    public void increment() {
        count++;  // 分三步:读取、+1、写回
    }
}

// 多线程执行结果
线程 A:读取 count=0 → 计算 1 → 写回 1
线程 B:读取 count=0 → 计算 1 → 写回 1
结果:count=1(预期 2)

// 解决方案 1:synchronized
public synchronized void increment() {
    count++;
}

// 解决方案 2:AtomicInteger(CAS)
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
    count.incrementAndGet();  // CAS 操作,无锁
}

// 双重检查锁的问题
public class Singleton {
    private static Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {              // 1
            synchronized (Singleton.class) {
                if (instance == null) {       // 2
                    instance = new Singleton(); // 3
                }
            }
        }
        return instance;
    }
}

// 问题:指令重排导致返回未初始化对象
// instance = new Singleton() 分三步:
// 1. 分配内存空间
// 2. 初始化对象
// 3. 将 instance 指向内存地址
//
// 重排后:1 → 3 → 2
// 线程 A 执行到 3,instance 已不为 null
// 线程 B 判断 instance != null,直接返回未初始化对象

// 解决方案:加 volatile 禁止重排
private static volatile Singleton instance;

// 1. 修饰实例方法:锁是当前对象
public synchronized void method1() {
    // 等价于 synchronized(this)
}

// 2. 修饰静态方法:锁是 Class 对象
public static synchronized void method2() {
    // 等价于 synchronized(ClassName.class)
}

// 3. 修饰代码块:自定义锁对象
public void method3() {
    synchronized (lock) {
        // 临界区
    }
}

// 源代码
public void method() {
    synchronized (this) {
        count++;
    }
}

// 字节码
public void method();
  Code:
     0: aload_0
     1: dup
     2: astore_1
     3: monitorenter      // 获取锁
     4: aload_0
     5: dup
     6: getfield
     9: iconst_1
    10: iadd
    11: putfield
    14: aload_1
    15: monitorexit       // 释放锁
    16: goto 24
    19: astore_2
    20: aload_1
    21: monitorexit       // 异常也要释放锁
    22: aload_2
    23: athrow

// 1. 偏向锁(Biased Locking)
场景:只有一个线程访问同步代码块
原理:
  - 对象头记录线程 ID
  - 下次该线程进入,直接获取锁,无需 CAS
  - 适合单线程重入场景

触发升级:
  - 其他线程尝试获取锁 → 升级为轻量级锁

// 2. 轻量级锁(Lightweight Locking)
场景:多个线程交替执行,无实际竞争
原理:
  - 线程在栈帧中创建锁记录(Lock Record)
  - CAS 将对象头的 Mark Word 替换为锁记录指针
  - 成功则获取锁,失败则自旋

自旋过程:
  while (!CAS(lockRecord)) {
      // 自旋等待(默认 10 次)
      // JDK 6+ 自适应自旋
  }

触发升级:
  - 自旋超过阈值
  - 线程数超过 CPU 核心数 / 2
  → 升级为重量级锁

// 3. 重量级锁(Heavyweight Locking)
场景:多线程实际竞争,自旋无效
原理:
  - 使用操作系统互斥量(Mutex)
  - 未获取锁的线程进入阻塞状态(BLOCKED)
  - 涉及用户态和内核态切换(开销大)

Monitor 结构:
  - _owner:持有锁的线程
  - _EntryList:等待锁的线程队列
  - _WaitSet:调用 wait() 的线程队列

// 高并发计数器
public class Counter {
    private int count = 0;

    // 错误示例:高竞争下频繁升级重量级锁
    public synchronized void increment() {
        count++;
    }
}

// 优化方案 1:分段锁(类似 ConcurrentHashMap)
public class SegmentCounter {
    private final int SEGMENT_COUNT = 16;
    private final int[] segments = new int[SEGMENT_COUNT];
    private final Object[] locks = new Object[SEGMENT_COUNT];

    public SegmentCounter() {
        for (int i = 0; i < SEGMENT_COUNT; i++) {
            locks[i] = new Object();
        }
    }

    public void increment() {
        int index = (int) (Thread.currentThread().getId() % SEGMENT_COUNT);
        synchronized (locks[index]) {
            segments[index]++;
        }
    }

    public int getCount() {
        int sum = 0;
        for (int segment : segments) {
            sum += segment;
        }
        return sum;
    }
}

// 优化方案 2:LongAdder(性能最优)
private LongAdder count = new LongAdder();
public void increment() {
    count.increment();
}

// 示例:并行查询多个数据源,汇总结果
public class DataAggregator {
    public Map<String, Object> queryAll() throws InterruptedException {
        Map<String, Object> result = new ConcurrentHashMap<>();
        CountDownLatch latch = new CountDownLatch(3);

        // 查询 MySQL
        new Thread(() -> {
            result.put("mysql", queryMySQL());
            latch.countDown();
        }).start();

        // 查询 Redis
        new Thread(() -> {
            result.put("redis", queryRedis());
            latch.countDown();
        }).start();

        // 查询 ES
        new Thread(() -> {
            result.put("es", queryES());
            latch.countDown();
        }).start();

        latch.await(5, TimeUnit.SECONDS);  // 最多等待 5 秒
        return result;
    }
}

// 示例:分批处理数据,每批 100 条一起入库
public class BatchProcessor {
    private CyclicBarrier barrier = new CyclicBarrier(10, () -> {
        // 10 个线程都到达后执行
        batchInsert();
    });

    public void process(Data data) {
        addToBuffer(data);
        try {
            barrier.await();  // 等待其他线程
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 示例:数据库连接池
public class ConnectionPool {
    private Semaphore semaphore = new Semaphore(10);  // 最多 10 个连接
    private List<Connection> connections = new ArrayList<>();

    public Connection getConnection() throws InterruptedException {
        semaphore.acquire();  // 获取许可
        return fetchConnection();
    }

    public void releaseConnection(Connection conn) {
        returnConnection(conn);
        semaphore.release();  // 释放许可
    }
}

// 限流器
public class RateLimiter {
    private Semaphore semaphore;

    public RateLimiter(int permitsPerSecond) {
        this.semaphore = new Semaphore(permitsPerSecond);

        // 每秒补充令牌
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> {
            semaphore.release(permitsPerSecond - semaphore.availablePermits());
        }, 1, 1, TimeUnit.SECONDS);
    }

    public boolean tryAcquire() {
        return semaphore.tryAcquire();
    }
}

public ThreadPoolExecutor(
    int corePoolSize,       // 核心线程数
    int maximumPoolSize,    // 最大线程数
    long keepAliveTime,     // 空闲线程存活时间
    TimeUnit unit,          // 时间单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

// 1. AbortPolicy(默认):抛出异常
new ThreadPoolExecutor.AbortPolicy()
// 抛出 RejectedExecutionException

// 2. CallerRunsPolicy:调用者线程执行
new ThreadPoolExecutor.CallerRunsPolicy()
// 降低任务提交速度,不丢弃任务

// 3. DiscardPolicy:直接丢弃
new ThreadPoolExecutor.DiscardPolicy()

// 4. DiscardOldestPolicy:丢弃最老的任务
new ThreadPoolExecutor.DiscardOldestPolicy()

// 5. 自定义策略
new RejectedExecutionHandler() {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 记录日志 + 入库 + 告警
        logger.warn("Task rejected: {}", r);
        saveToDatabase(r);
        sendAlert();
    }
}

// CPU 密集型:线程数 = CPU 核心数 + 1
int cpuCount = Runtime.getRuntime().availableProcessors();
ExecutorService executor = Executors.newFixedThreadPool(cpuCount + 1);

// IO 密集型:线程数 = CPU 核心数 * 2 或更多
// 公式:线程数 = CPU 核心数 * (1 + IO 耗时 / CPU 耗时)
// 示例:IO 耗时 100ms,CPU 耗时 10ms
// 线程数 = 8 * (1 + 100/10) = 88

// 实际案例:HTTP 接口调用
ExecutorService executor = new ThreadPoolExecutor(
    10,                         // 核心线程数
    50,                         // 最大线程数
    60, TimeUnit.SECONDS,       // 空闲 60s 回收
    new LinkedBlockingQueue<>(1000),  // 队列 1000
    new ThreadFactoryBuilder()
        .setNameFormat("http-pool-%d")
        .build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

public class DynamicThreadPool {
    private ThreadPoolExecutor executor;

    public DynamicThreadPool() {
        executor = new ThreadPoolExecutor(
            10, 50, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );

        // 监控线程池,动态调整
        ScheduledExecutorService monitor = Executors.newScheduledThreadPool(1);
        monitor.scheduleAtFixedRate(() -> {
            int activeCount = executor.getActiveCount();
            int poolSize = executor.getPoolSize();
            int queueSize = executor.getQueue().size();

            // 活跃线程 > 80%,扩容
            if (activeCount > poolSize * 0.8) {
                executor.setMaximumPoolSize(Math.min(poolSize + 10, 200));
            }

            // 队列堆积 > 500,扩容
            if (queueSize > 500) {
                executor.setCorePoolSize(Math.min(executor.getCorePoolSize() + 5, 50));
            }

            logger.info("ThreadPool: active={}, pool={}, queue={}",
                activeCount, poolSize, queueSize);
        }, 10, 10, TimeUnit.SECONDS);
    }
}

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

// 1. 计算 hash
static final int hash(Object key) {
    int h;
    // 高 16 位异或低 16 位,减少碰撞
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// 2. putVal 流程
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;

    // 1) 表为空,初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

    // 2) 计算索引:i = (n - 1) & hash
    // 等价于 hash % n,但位运算更快
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);  // 无冲突,直接放入
    else {
        Node<K,V> e; K k;

        // 3) 头节点匹配
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;

        // 4) 红黑树节点
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

        // 5) 链表节点
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 链表长度 ≥ 8,树化
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;  // 找到相同 key
                p = e;
            }
        }

        // 6) key 已存在,更新 value
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            return oldValue;
        }
    }

    // 7) size++,检查是否需要扩容
    if (++size > threshold)
        resize();
    return null;
}

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int newCap = oldCap << 1;  // 扩容为 2 倍

    // 重新计算阈值:threshold = capacity * loadFactor
    int newThr = (int)(newCap * loadFactor);  // 默认 0.75

    Node<K,V>[] newTab = new Node[newCap];
    table = newTab;

    // 重新分配节点
    for (int j = 0; j < oldCap; ++j) {
        Node<K,V> e = oldTab[j];
        if (e != null) {
            oldTab[j] = null;

            // 只有一个节点
            if (e.next == null)
                newTab[e.hash & (newCap - 1)] = e;

            // 红黑树
            else if (e instanceof TreeNode)
                ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

            // 链表:拆分为两条链表
            else {
                // JDK 1.8 优化:根据 (e.hash & oldCap) 分组
                // 结果为 0:索引不变(loHead)
                // 结果为 1:索引 = j + oldCap(hiHead)
                Node<K,V> loHead = null, loTail = null;
                Node<K,V> hiHead = null, hiTail = null;
                Node<K,V> next;
                do {
                    next = e.next;
                    if ((e.hash & oldCap) == 0) {
                        if (loTail == null) loHead = e;
                        else loTail.next = e;
                        loTail = e;
                    } else {
                        if (hiTail == null) hiHead = e;
                        else hiTail.next = e;
                        hiTail = e;
                    }
                } while ((e = next) != null);

                if (loTail != null) {
                    loTail.next = null;
                    newTab[j] = loHead;
                }
                if (hiTail != null) {
                    hiTail.next = null;
                    newTab[j + oldCap] = hiHead;
                }
            }
        }
    }
    return newTab;
}

// JDK 1.7 死循环问题
场景:多线程同时扩容
原因:链表采用头插法,扩容时可能形成环

线程 A:扩容中,执行到一半被挂起
  原链表:1 → 2 → 3
  新链表:1

线程 B:完成扩容
  新链表:3 → 2 → 1

线程 A:恢复执行
  尝试插入 2 → 1
  形成环:1 ↔ 2

解决:
1. 使用 ConcurrentHashMap
2. Collections.synchronizedMap(new HashMap<>())

结构:Segment[] + HashEntry[]
锁粒度:Segment(默认 16 个)

class Segment<K,V> extends ReentrantLock {
    HashEntry<K,V>[] table;
}

put 操作:
1. 计算 segment 索引
2. 获取 segment 的锁
3. 在 segment 内的 table 中插入

并发度:最多 16 个线程同时写(每个 segment 一个线程)

结构:Node[] + 链表/红黑树
锁粒度:Node(数组元素)

put 操作:
1. 计算 hash,定位到 Node
2. 如果 Node 为空:CAS 插入
3. 如果 Node 不为空:synchronized 锁住 Node,插入链表/红黑树

// 关键代码
final V putVal(K key, V value, boolean onlyIfAbsent) {
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;

        // 1. 表未初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();

        // 2. 桶为空,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;
        }

        // 3. 正在扩容,帮助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);

        // 4. 锁住桶,插入链表/红黑树
        else {
            V oldVal = null;
            synchronized (f) {  // 锁粒度:单个桶
                // 链表插入逻辑
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode());
    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;
        }

        // 红黑树查找
        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;
}

// 为什么 get 不用锁?
// 1. Node 的 val 和 next 都是 volatile
// 2. 读到的一定是最新值或旧值,不会读到中间状态

// JDK 1.7:遍历所有 Segment,重试 3 次不一致则加锁
// JDK 1.8:使用 baseCount + CounterCell[]

private transient volatile long baseCount;
private transient volatile CounterCell[] counterCells;

// put 时更新计数
private final void addCount(long x, int check) {
    // 尝试更新 baseCount
    if (CAS(baseCount, baseCount + x)) {
        return;
    }

    // 失败则使用 CounterCell(类似 LongAdder)
    CounterCell[] as;
    if ((as = counterCells) != null) {
        int index = ThreadLocalRandom.current().nextInt(as.length);
        as[index].value += x;
    }
}

// 计算 size
public long size() {
    long sum = baseCount;
    if (counterCells != null) {
        for (CounterCell cell : counterCells) {
            sum += cell.value;
        }
    }
    return sum;
}

完整流程:
1. 实例化(Instantiation)
2. 属性赋值(Populate)
3. 初始化(Initialization)
   - Aware 接口回调
   - BeanPostProcessor.postProcessBeforeInitialization()
   - InitializingBean.afterPropertiesSet()
   - 自定义 init-method
   - BeanPostProcessor.postProcessAfterInitialization()
4. 使用(In Use)
5. 销毁(Destruction)
   - DisposableBean.destroy()
   - 自定义 destroy-method

// 示例代码
@Component
public class UserService implements BeanNameAware, InitializingBean, DisposableBean {

    private UserRepository userRepository;

    // 1. 构造函数:实例化
    public UserService() {
        System.out.println("1. 构造函数");
    }

    // 2. 依赖注入:属性赋值
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        System.out.println("2. 属性赋值");
        this.userRepository = userRepository;
    }

    // 3. Aware 回调
    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware: " + name);
    }

    // 4. BeanPostProcessor 前置处理
    // (由 Spring 容器自动调用)

    // 5. InitializingBean
    @Override
    public void afterPropertiesSet() {
        System.out.println("5. InitializingBean.afterPropertiesSet()");
    }

    // 6. 自定义初始化方法
    @PostConstruct
    public void init() {
        System.out.println("6. @PostConstruct");
    }

    // 7. BeanPostProcessor 后置处理
    // (AOP 代理在这里生成)

    // 8. 销毁
    @PreDestroy
    public void preDestroy() {
        System.out.println("8. @PreDestroy");
    }

    @Override
    public void destroy() {
        System.out.println("9. DisposableBean.destroy()");
    }
}

// 场景
@Service
public class A {
    @Autowired
    private B b;
}

@Service
public class B {
    @Autowired
    private A a;
}

// 三级缓存机制
public class DefaultSingletonBeanRegistry {
    // 一级缓存:成品 Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    // 二级缓存:半成品 Bean(已实例化,未初始化)
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

    // 三级缓存:Bean 工厂(用于提前暴露 AOP 代理)
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

// 创建流程
1. 创建 A:
   - 实例化 A,放入三级缓存
   - 填充属性,发现依赖 B

2. 创建 B:
   - 实例化 B,放入三级缓存
   - 填充属性,发现依赖 A

3. 获取 A:
   - 一级缓存没有
   - 二级缓存没有
   - 三级缓存有,调用 ObjectFactory 创建 A 的早期引用
   - 将 A 的早期引用放入二级缓存
   - 返回 A 的早期引用给 B

4. B 初始化完成:
   - B 放入一级缓存

5. A 继续初始化:
   - A 放入一级缓存

// 为什么需要三级缓存?
// 二级缓存足够解决循环依赖,但 AOP 需要三级缓存
// 三级缓存存储 ObjectFactory,用于延迟创建代理对象
// 如果 A 需要代理,ObjectFactory.getObject() 返回代理对象

@Service
public class A {
    public A(B b) {}  // 构造器注入
}

@Service
public class B {
    public B(A a) {}  // 构造器注入
}

// 报错:BeanCurrentlyInCreationException
// 原因:实例化前无法提前暴露引用

// 解决方案
1. 改为 @Autowired 字段注入或 Setter 注入
2. 使用 @Lazy 延迟加载
   @Service
   public class A {
       public A(@Lazy B b) {}
   }

// 只能代理接口
public interface UserService {
    void save(User user);
}

@Service
public class UserServiceImpl implements UserService {
    public void save(User user) {
        System.out.println("保存用户:" + user);
    }
}

// 代理类
public class JdkProxyFactory implements InvocationHandler {
    private Object target;

    public Object createProxy(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置通知");
        Object result = method.invoke(target, args);
        System.out.println("后置通知");
        return result;
    }
}

// 使用
UserService target = new UserServiceImpl();
UserService proxy = (UserService) new JdkProxyFactory().createProxy(target);
proxy.save(new User());

// 可以代理类(通过继承)
@Service
public class UserService {  // 没有接口
    public void save(User user) {
        System.out.println("保存用户:" + user);
    }
}

// 代理类
public class CglibProxyFactory implements MethodInterceptor {

    public Object createProxy(Class<?> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable {
        System.out.println("前置通知");
        Object result = proxy.invokeSuper(obj, args);  // 调用父类方法
        System.out.println("后置通知");
        return result;
    }
}

// 使用
UserService proxy = (UserService) new CglibProxyFactory().createProxy(UserService.class);
proxy.save(new User());

// 场景 1:方法不是 public
@Transactional
private void save() {}  // 事务不生效

// 原因:Spring AOP 默认只代理 public 方法

// 场景 2:同类方法调用
@Service
public class UserService {

    @Transactional
    public void save(User user) {
        // ...
    }

    public void batchSave(List<User> users) {
        for (User user : users) {
            this.save(user);  // 事务不生效!
        }
    }
}

// 原因:this.save() 调用的是原始对象,不是代理对象
// 解决方案 1:注入自己
@Service
public class UserService {
    @Autowired
    private UserService self;  // 注入代理对象

    public void batchSave(List<User> users) {
        for (User user : users) {
            self.save(user);  // 调用代理对象
        }
    }
}

// 解决方案 2:获取代理对象
AopContext.currentProxy()

// 场景 3:异常被捕获
@Transactional
public void save(User user) {
    try {
        // ...
        throw new Exception();
    } catch (Exception e) {
        // 吞掉异常,事务不回滚
    }
}

// 解决:手动回滚
catch (Exception e) {
    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

// 场景 4:异常类型不匹配
@Transactional  // 默认只回滚 RuntimeException 和 Error
public void save(User user) throws Exception {
    throw new Exception();  // 不回滚
}

// 解决:指定异常类型
@Transactional(rollbackFor = Exception.class)

// 方案 1:使用 Guava Cache,自动过期
@Component
public class UserCache {
    private LoadingCache<Long, User> cache = CacheBuilder.newBuilder()
        .maximumSize(100000)  // 最多缓存 10 万个
        .expireAfterWrite(30, TimeUnit.MINUTES)  // 30 分钟过期
        .build(new CacheLoader<Long, User>() {
            public User load(Long id) {
                return userRepository.findById(id).orElse(null);
            }
        });

    public User getUser(Long id) {
        return cache.getUnchecked(id);
    }
}

// 方案 2:使用 Redis 缓存
@Service
public class UserService {
    @Autowired
    private RedisTemplate<String, User> redisTemplate;

    @Cacheable(value = "user", key = "#id", unless = "#result == null")
    public User getUser(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

// 方案 3:分页加载
@Component
public class UserCache {
    private Map<Long, User> cache = new ConcurrentHashMap<>();

    @Scheduled(fixedRate = 60000)
    public void refreshCache() {
        int pageSize = 1000;
        int pageNo = 0;
        Page<User> page;

        do {
            page = userRepository.findAll(PageRequest.of(pageNo++, pageSize));
            for (User user : page.getContent()) {
                cache.put(user.getId(), user);
            }
        } while (page.hasNext());
    }
}

==:
- 基本类型:比较值
- 引用类型:比较内存地址

equals:
- Object 默认实现:return this == obj;
- String 重写:比较字符内容
- 自定义对象需重写

// 示例
String s1 = new String("hello");
String s2 = new String("hello");
s1 == s2        // false(不同对象)
s1.equals(s2)   // true(内容相同)

// 字符串常量池
String s3 = "hello";
String s4 = "hello";
s3 == s4        // true(指向常量池同一对象)

原因:HashMap 等集合依赖 hashCode 定位桶,再用 equals 判断

// 反例
public class User {
    private Long id;

    @Override
    public boolean equals(Object obj) {
        return this.id.equals(((User) obj).id);
    }
    // 未重写 hashCode
}

User u1 = new User(1L);
User u2 = new User(1L);

Map<User, String> map = new HashMap<>();
map.put(u1, "张三");
map.get(u2);  // null!

// 原因:u1 和 u2 的 hashCode 不同,定位到不同的桶

// 正确做法
@Override
public int hashCode() {
    return Objects.hash(id);
}

// 方案 1:Redis SETNX
public boolean tryLock(String key, String value, int expireSeconds) {
    String result = jedis.set(key, value, "NX", "EX", expireSeconds);
    return "OK".equals(result);
}

public void unlock(String key, String value) {
    // Lua 脚本保证原子性
    String script =
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "    return redis.call('del', KEYS[1]) " +
        "else return 0 end";
    jedis.eval(script, Collections.singletonList(key), Collections.singletonList(value));
}

// 方案 2:Redisson(推荐)
RLock lock = redisson.getLock("myLock");
try {
    lock.lock(10, TimeUnit.SECONDS);  // 自动续期
    // 业务逻辑
} finally {
    lock.unlock();
}

// 方案 3:ZooKeeper 临时顺序节点