十月通勤小记

一、JVM核心原理（通勤20分钟/天，7天掌握）

1. 类加载机制
   双亲委派模型：
   流程：类加载器收到请求后，先委托父加载器处理，父无法完成时自身才加载。
   目的：避免类重复加载，保证核心类安全性（如防止恶意替换String类）。
   破坏案例：SPI机制中DriverManager通过线程上下文加载数据库驱动类。
   类加载过程：
   加载：读取.class文件，生成Class对象。
   验证：检查字节码是否符合JVM规范（如魔数、常量池类型）。
   准备：为静态变量分配内存并赋默认值（int为0，引用为null）。
   解析：将符号引用转为直接引用（如方法调用指向具体内存地址）。
   初始化：执行静态代码块、静态变量赋值。
2. 内存模型
   堆内存：
   分区：新生代（Eden:Survivor=8:1:1）、老年代。
   GC触发：Eden区满时触发Minor GC，老年代满时触发Full GC。
   调优参数：-Xms（初始堆）、-Xmx（最大堆）、-XX:SurvivorRatio（Eden与Survivor比例）。
   方法区（元空间）：
   存储内容：类元数据、常量池、静态变量。
   演进：JDK 8前为永久代（堆内），JDK 8后改为元空间（本地内存）。
   OOM场景：动态生成类过多（如CGLIB代理、ASM字节码操作）。
3. 垃圾回收
   CMS vs G1：
   CMS：并发标记清除，减少停顿但易产生碎片（需-XX:+UseCMSCompactAtFullCollection）。
   G1：分区收集，优先回收高价值区域（-XX:+UseG1GC），适合大堆（>4GB）。
   关键指标：
   吞吐量：GC时间占总运行时间比例（如99%吞吐量表示1%时间用于GC）。
   停顿时间：G1可通过-XX:MaxGCPauseMillis控制最大停顿（默认200ms）。
   二、并发编程进阶（通勤25分钟/天，10天掌握）
4. 线程安全与锁
   synchronized优化：
   锁升级：无锁→偏向锁→轻量级锁→重量级锁（JDK 6后优化）。
   锁消除：JIT编译时移除不必要的同步（如栈上分配的对象）。
   ReentrantLock：
   特性：支持公平锁、可中断锁、超时获取锁（tryLock(long, TimeUnit)）。
   适用场景：需要灵活控制锁的场景（如限流器）。
5. 并发工具类
   CountDownLatch：
   场景：主线程等待多个子线程完成（如初始化多个模块后启动服务）。
   示例：
   java
   CountDownLatch latch = new CountDownLatch(3);
   new Thread(() -> { latch.countDown(); }).start();
   latch.await(); // 阻塞直到计数为0
   CyclicBarrier：
   场景：多线程互相等待至共同点（如并行计算分阶段汇总）。
   与CountDownLatch区别：可重复使用（reset()方法）。
6. 原子类与CAS
   AtomicInteger：
   原理：基于CAS（Compare-And-Swap）实现无锁更新。
   示例：
   java
   AtomicInteger counter = new AtomicInteger(0);
   counter.incrementAndGet(); // 原子++操作
   ABA问题：
   场景：值从A→B→A，CAS误认为未变化。
   解决方案：使用AtomicStampedReference（带版本号的原子引用）。
   三、分布式系统理论（通勤30分钟/天，12天掌握）
7. CAP与BASE
   CAP三选二：
   CP：Zookeeper（一致性优先，牺牲可用性）。
   AP：Cassandra（可用性优先，最终一致性）。
   BASE理论：
   Basically Available：允许部分节点失败。
   Soft State：系统状态可有一定延迟。
   Eventually Consistent：最终数据一致（如通过版本号、向量时钟实现）。
8. 分布式事务
   2PC vs TCC：
   2PC：阻塞式（XA协议），适用于强一致性场景（如数据库内置事务）。
   TCC：补偿式（Try-Confirm-Cancel），适用于长事务（如支付+物流）。
   Seata示例：
   java
   @GlobalTransactional
   public void order(Order order) {
   // 调用库存服务扣减库存
   inventoryService.deduct(order);
   // 调用支付服务完成支付
   paymentService.pay(order);
   }
9. 分布式缓存
   Redis集群：
   分区策略：哈希槽（16384个槽，通过CRC16(key)%16384分配）。
   故障恢复：主从复制+哨兵监控（自动故障转移）。
   缓存问题：
   雪崩：大量缓存同时失效导致数据库压力激增（解决方案：随机过期时间）。
   穿透：查询不存在的数据频繁访问数据库（解决方案：布隆过滤器）。
   四、设计模式精选（通勤15分钟/天，6天掌握）
10. 创建型模式
    工厂方法：
    场景：定义创建对象的接口，子类决定实例化类（如Spring的BeanFactory）。
    示例：
    java
    interface Product { void use(); }
    class ConcreteProductA implements Product { public void use() { System.out.println(“A”); } }
    class Factory {
    public Product create(String type) {
    if (“A”.equals(type)) return new ConcreteProductA();
    return null;
    }
    }
    单例模式：
    双重检查锁定：
    java
    public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
    if (instance == null) {
    synchronized (Singleton.class) {
    if (instance == null) instance = new Singleton();
    }
    }
    return instance;
    }
    }
11. 结构型模式
    适配器模式：
    场景：转换接口（如将JDBC适配为DataSource）。
    示例：
    java
    interface Target { void request(); }
    class Adaptee { public void specificRequest() { System.out.println(“Adaptee”); } }
    class Adapter implements Target {
    private Adaptee adaptee = new Adaptee();
    public void request() { adaptee.specificRequest(); }
    }
    装饰器模式：
    场景：动态添加职责（如BufferedInputStream包装FileInputStream）。
    示例：
    java
    interface Component { void operation(); }
    class ConcreteComponent implements Component { public void operation() { System.out.println(“Base”); } }
    class Decorator implements Component {
    private Component component;
    public Decorator(Component c) { this.component = c; }
    public void operation() {
    component.operation();
    System.out.println(“Decorator”);
    }
    }
12. 行为型模式
    策略模式：
    场景：封装算法（如支付方式选择）。
    示例：
    java
    interface PaymentStrategy { void pay(double amount); }
    class CreditCardPayment implements PaymentStrategy {
    public void pay(double amount) { System.out.println(“Paid " + amount + " via CreditCard”); }
    }
    class Context {
    private PaymentStrategy strategy;
    public Context(PaymentStrategy s) { this.strategy = s; }
    public void executePayment(double amount) { strategy.pay(amount); }
    }
    观察者模式：
    场景：事件驱动（如GUI按钮点击事件）。
    示例：
    java
    interface Observer { void update(String message); }
    class ConcreteObserver implements Observer {
    public void update(String message) { System.out.println("Received: " + message); }
    }
    class Subject {
    private List observers = new ArrayList<>();
    public void addObserver(Observer o) { observers.add(o); }
    public void notifyObservers(String message) {
    for (Observer o : observers) o.update(message);
    }
    }