← 返回首页 🔍 追问串联
📐 学习维度 本篇是 🔍 追问串联 🏠 首页 🛤️ 学习路径 📚 全部文章
📑 本篇章节导航 (共8章,点击直达)
一、acquire()流程(源码级手推)二、FactoryBean(高频混淆题)三、MySQL自适应Hash索引(AHI)四、Kafka日志段(Segment)管理五、Docker镜像安全扫描真题来源相关页面🚀 下一篇
## 🎯 本文在学习路径中的位置
📍 L4 存储阶段 · Day 4-9(综合追问精讲 3 · 五连击深度追问)

一、acquire()流程(源码级手推)


// AQS源码(AbstractQueuedSynchronizer)
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&                    // 1.尝试获取锁(子类实现)
        acquireQueued(                          // 3.入队等待
            addWaiter(Node.EXCLUSIVE), arg))    // 2.加到CLH队列
        selfInterrupt();                        // 4.中断恢复
}

tryAcquire(子类实现,ReentrantLock为例)


// ReentrantLock.NonfairSync.tryAcquire (非公平锁)
final boolean nonfairTryAcquire(int acquires) {
    Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {                              // 没人持锁
        if (compareAndSetState(0, acquires)) { // CAS抢锁
            setExclusiveOwnerThread(current);   // 设持有线程
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) { // 自己持的锁(可重入)
        int nextc = c + acquires;               // state+1(重入计数)
        setState(nextc);
        return true;
    }
    return false;                               // 抢锁失败
}

addWaiter(加入CLH队列)


private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode); // 创建Node
    Node pred = tail;
    if (pred != null) {                         // 队列不空→CAS加到尾部
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);                                  // 队列空/CAS失败→自旋入队
    return node;
}

acquireQueued(队列中等待+自旋)


final boolean acquireQueued(Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {                              // 自旋
            final Node p = node.predecessor();   // 前驱节点
            if (p == head && tryAcquire(arg)) {  // 前驱是head→再试一次获取锁
                setHead(node);                    // 成功→自己变head
                p.next = null;                   // 帮GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) && // 判断能不能park
                parkAndCheckInterrupt())                  // park阻塞
                interrupted = true;
        }
    } finally {
        if (failed) cancelAcquire(node);
    }
}

追问链


Q1: 公平锁和非公平锁的tryAcquire区别?
A: 非公平:c==0时直接CAS抢(不等队列)
   公平:c==0时先hasQueuedPredecessors()检查队列有没有人排着
   → 公平排队,非公平抢
   → 非公平吞吐量高(减少线程切换)

Q2: shouldParkAfterFailedAcquire做什么?
A: 检查前驱节点的waitStatus:
   SIGNAL(-1)→前驱会唤醒我→可以park
   否则→CAS把前驱设为SIGNAL(告诉前驱"你完了叫我")
   → 保证park后一定有人unpark(不会漏唤醒)

Q3: release怎么唤醒后继?
A: release(arg)→tryRelease(arg)(state-1→0)→unparkSuccessor(head)
   → 找head的后继→LockSupport.unpark(后继线程)
   → 后继从parkAndCheckInterrupt()醒来→继续自旋tryAcquire

中篇:Spring FactoryBean与MySQL AHI

二、FactoryBean(高频混淆题)


FactoryBean = 一种特殊的Bean(自己创建对象的Bean)

区别(必背):
  BeanFactory:IoC容器(管理所有Bean的工厂,顶层接口)
  FactoryBean:一种Bean(能创建其他对象的Bean)

FactoryBean接口:
  interface FactoryBean<T> {
      T getObject() throws Exception;  // ★ 返回实际对象(可能是代理/复杂对象)
      Class<?> getObjectType();         // 返回对象类型
      boolean isSingleton();             // 是否单例
  }

使用场景:
  ①MyBatis的SqlSessionFactoryBean:getObject()返回SqlSessionFactory
  ②Spring AOP的ProxyFactoryBean:getObject()返回代理对象
  ③Spring Data Elasticsearch:ElasticsearchTemplate FactoryBean

获取:
  context.getBean("myFactoryBean") → 返回getObject()的结果(不是FactoryBean本身)
  context.getBean("&myFactoryBean") → 返回FactoryBean本身(&前缀)

追问


Q: 为什么不用@Bean而用FactoryBean?
A: @Bean:简单(直接return new Xxx())
   FactoryBean:需要复杂创建逻辑(循环引用/代理/懒加载/生命周期回调)
   → MyBatis的Mapper用FactoryBean(MapperProxy动态代理→getObject返回代理)

三、MySQL自适应Hash索引(AHI)


AHI(Adaptive Hash Index) = InnoDB自动建的Hash索引(优化热点查询)

原理:
  InnoDB是B+树索引(O(log n))
  如果某些索引页被频繁访问(热点)→InnoDB自动在内存建Hash索引(O(1))
  → 等值查询命中Hash→直接定位(O(1))

特点:
  ①自动(不需要手动建)
  ②内存中(不占磁盘)
  ③只对热点页建(不是所有索引)
  ④等值查询加速(范围查询用不上)

innodb_adaptive_hash_index = ON(默认)

追问:
  Q: AHI什么时候有害?
  A: 高并发写场景→Hash索引要同步更新(锁竞争)→性能降
     → 如果AHI成为瓶颈→关闭(innodb_adaptive_hash_index=OFF)

  Q: AHI和手动建Hash索引区别?
  A: AHI:InnoDB内部自动管理(B+树基础上叠加,对用户透明)
     手动Hash索引:MySQL不支持InnoDB手动建Hash(InnoDB只有B+树)
     → AHI是InnoDB的优化,不是用户能控制的

下篇:Kafka Segment管理与Docker镜像扫描

四、Kafka日志段(Segment)管理


每个分区(Partition)是一个目录,含多个Segment(日志段):

partition-0/
  00000000000000000000.log       ★ 消息数据
  00000000000000000000.index     偏移量索引(稀疏)
  00000000000000000000.timeindex 时间戳索引
  00000000000000123456.log       下一个Segment(文件名=起始offset)
  00000000000000123456.index
  00000000000000123456.timeindex
  leader-epoch-checkpoint        Leader纪元

Segment命名规则:
  文件名 = 该Segment的第一条消息的offset(补零到20位)
  00000000000000000000 = offset 0开始
  00000000000000123456 = offset 123456开始

Segment切分条件:
  ①大小满(segment.bytes,默认1GB)
  ②时间满(segment.ms,默认7天)
  → 满足任一→创建新Segment

追问:
  Q1: .index文件是什么?
  A: 稀疏索引(不是每条消息都有)。
     存:offset → 物理位置(log文件中的字节位置)
     消费者请求offset→二分查找.index→定位.log→顺序读
     稀疏(每隔一定条数记一次)→省空间(全量索引太大)

  Q2: 怎么快速定位某offset的消息?
  A: 1.二分查找Segment文件名(定位在哪个Segment)
     2.在.index里二分查找offset(定位物理位置)
     3.在.log里从物理位置读(顺序读)
     → O(log n)定位(不用全扫描)

  Q3: Segment什么时候删?
  A: ①按时间删(log retention hours/ms,默认7天)
     ②按大小删(log retention bytes)
     ③Compact模式(只保留最新key值)
     → 删整个Segment文件(不删单条消息)

五、Docker镜像安全扫描


# Trivy扫描(免费,最常用)
trivy image myapp:latest
# 输出:CVE漏洞列表(CVE-2024-XXXX, 严重级别, 修复版本)

# Docker Scout(Docker官方)
docker scout cves myapp:latest

# Harbor内置扫描(推送时自动)
# 配置Harbor的扫描策略→推送镜像→自动扫描→报告漏洞

安全最佳实践


1.定期扫描(每次构建扫描)
  CI/CD加扫描步骤→有高危CVE→阻断部署

2.用小基础镜像(漏洞少)
  alpine(比ubuntu少很多包→少漏洞)
  distroless(无shell→更安全)

3.及时更新基础镜像
  定期docker pull eclipse-temurin:17-jre-jammy(获取安全补丁)
  不要用过时的tag(如openjdk:8,已停止更新)

4.多阶段构建(构建工具不入最终镜像)
  构建阶段的Maven/编译器可能有漏洞→不进最终镜像

5.最小权限(容器不用root)
  USER 1000:1000  # Dockerfile指定非root用户

6.只读文件系统
  docker run --read-only  # 只读(防写入恶意文件)

追问:
  Q: CVE严重级别?
  A: CRITICAL(严重)→必须修
     HIGH(高)→应该修
     MEDIUM(中)→计划修
     LOW(低)→可忽略
     生产:CRITICAL+HIGH必须修复才能部署。

  Q: 怎么修镜像漏洞?
  A: ①更新基础镜像(基镜像版本升级→获取安全补丁)
     ②更新依赖(jar包升级→修CVE)
     ③换无漏洞的替代(如log4j漏洞→升级)
     ④如果无法修→加WAF/网络隔离(缓解)

真题来源


相关页面


🚀 下一篇

下一篇:Filter与Interceptor与AOP顺序与MySQL索引失效与Redis脑裂与K8s StatefulSet追问精讲(L4 · Day 4-10 · 综合 4)

为什么接下来学这个:

本文深挖了 AQS 源码 + FactoryBean + MySQL AHI + Kafka Segment + Docker 镜像扫描 五大源码级追问,但 L4 综合追问还没完——下一篇继续追问 Web 请求链路 + 索引失效 + Redis 高可用 + K8s 有状态服务 四大经典方向:Filter/Interceptor/AOP 执行顺序(高频面试题)+ MySQL 索引失效 7 大场景(与 L4-2 互补)+ Redis Cluster 脑裂(与 L4-7 互补)+ K8s StatefulSet(MySQL/Redis 有状态部署必备)。

衔接要点(学完本文你已经掌握):

回链导航:学习路径地图 · JUC并发编程深度与AQS源码面试精讲


本文是 L4 阶段综合追问的第 3 篇,串联 并发基础(AQS)+ Spring(FactoryBean)+ MySQL(AHI)+ Kafka(Segment)+ DevOps(Docker 扫描) 五大模块的源码级追问。学完本文,你应该能在白板上手画 AQS acquire 流程 + FactoryBean 三方法 + Kafka Segment 稀疏索引——这就是 25K Java 高级工程师的底气。下一篇继续 L4-10 综合追问 4,把 Web 链路 / 索引失效 / 脑裂 / StatefulSet 这条线打通。