一、JVM与内存管理场景题

1.1 内存溢出定位与解决方案

典型场景：生产环境频繁出现java.lang.OutOfMemoryError，如何快速定位问题？
解题要点：

• 诊断工具链：使用jmap -histo:live <pid>分析对象分布，结合jstack <pid>排查线程阻塞
• 分代策略：区分Young GC与Full GC触发条件，例如Eden区满触发Minor GC，老年代不足触发Full GC
• 案例解析：

  // 模拟内存泄漏代码
  public class MemoryLeakDemo {
    private static final List<byte[]> CACHE = new ArrayList<>();
    public static void main(String[] args) {
        while (true) {
            CACHE.add(new byte[1024 * 1024]); // 持续添加1MB数组
        }
    }
  }

  解决方案：

1. 启用-XX:+HeapDumpOnOutOfMemoryError参数自动生成堆转储文件
2. 使用MAT工具分析大对象路径，定位缓存未清理问题
3. 调整JVM参数：-Xms512m -Xmx2g -XX:MaxMetaspaceSize=256m

1.2 GC日志分析与调优

进阶问题：如何通过GC日志判断是否需要调优？
关键指标：

• 单次Full GC耗时超过500ms
• 10分钟内Full GC次数超过3次
• 老年代使用率持续超过80%
  日志示例：

  2023-03-15T10:00:00.123+0800: 12345.678: [Full GC (Ergonomics) [PSYoungGen: 1024K->0K(1024K)] [ParOldGen: 2048K->1536K(4096K)] 3072K->1536K(5120K), [Metaspace: 2048K->2048K(1056768K)], 0.0456789 secs]

  调优策略：

1. 选择合适的GC算法：
   • 低延迟场景：G1（-XX:+UseG1GC）
   • 高吞吐场景：Parallel GC（-XX:+UseParallelGC）
2. 调整分代大小：

   -XX:NewRatio=3  # 老年代/新生代=3:1
   -XX:SurvivorRatio=8  # Eden/Survivor=81

二、并发编程实战题

2.1 多线程安全设计

经典问题：如何实现一个线程安全的计数器？
方案对比：
| 方案 | 性能 | 复杂度 | 适用场景 |
|———————-|———|————|————————————|
| synchronized | 低 | 低 | 简单计数场景 |
| AtomicInteger | 高 | 中 | 高频更新场景 |
| LongAdder | 极高 | 高 | 并发量>1000时优势明显 |

代码示例：

// LongAdder高性能实现
import java.util.concurrent.atomic.LongAdder;
public class ConcurrentCounter {
    private final LongAdder counter = new LongAdder();
    public void increment() {
        counter.increment();
    }
    public long get() {
        return counter.sum();
    }
}

2.2 线程池配置陷阱

陷阱场景：为什么线程池核心线程数设为CPU核心数+1？
原理分析：

• IO密集型任务：核心线程数 = CPU核心数 * (1 + 平均等待时间/平均计算时间)
• 计算密集型任务：核心线程数 ≈ CPU核心数
  配置示例：

  ExecutorService executor = new ThreadPoolExecutor(
    Runtime.getRuntime().availableProcessors() * 2, // 核心线程
    50, // 最大线程
    60, TimeUnit.SECONDS, // 空闲存活时间
    new LinkedBlockingQueue<>(1000), // 任务队列
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
  );

三、Spring生态核心题

3.1 循环依赖破解

面试题：Spring如何解决属性注入导致的循环依赖？
三级缓存机制：

1. SingletonObjects：完整Bean缓存
2. EarlySingletonObjects：半成品Bean缓存
3. SingletonFactories：ObjectFactory工厂缓存

处理流程：

graph TD
    A[BeanA创建] --> B[填充属性时发现依赖BeanB]
    B --> C[触发BeanB创建]
    C --> D[BeanB填充属性时发现依赖BeanA]
    D --> E[从三级缓存获取BeanA的半成品]
    E --> F[完成BeanB初始化]
    F --> G[将BeanB注入BeanA]

3.2 AOP实现原理

深度问题：Spring AOP与AspectJ的区别？
| 特性 | Spring AOP | AspectJ |
|———————-|——————|———————-|
| 编织时机 | 运行时 | 编译时/加载时 |
| 切点表达式 | 简单方法名 | 复杂条件组合 |
| 性能影响 | 较高 | 较低 |

动态代理示例：

// JDK动态代理实现
public class LoggingProxy implements InvocationHandler {
    private final Object target;
    public LoggingProxy(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

四、数据库优化专题

4.1 索引失效场景

典型案例：为什么WHERE name LIKE '%张%'不走索引？
失效场景全览：

1. 对索引列使用函数：WHERE YEAR(create_time) = 2023
2. 隐式类型转换：WHERE id = '123'（id为数字类型）
3. 复合索引未遵循最左前缀原则
4. 使用OR连接不同条件

优化方案：

-- 错误写法
SELECT * FROM user WHERE name LIKE '%张%';
-- 优化方案1：使用全文索引
ALTER TABLE user ADD FULLTEXT INDEX ft_name(name);
SELECT * FROM user WHERE MATCH(name) AGAINST('张' IN BOOLEAN MODE);
-- 优化方案2：考虑ES等搜索引擎

4.2 事务隔离级别实战

场景题：如何解决”不可重复读”问题？
隔离级别对比：
| 级别 | 脏读 | 不可重复读 | 幻读 |
|———————-|———|——————|———|
| READ UNCOMMITTED | ✓ | ✓ | ✓ |
| READ COMMITTED | ✗ | ✓ | ✓ |
| REPEATABLE READ | ✗ | ✗ | ✓* |
| SERIALIZABLE | ✗ | ✗ | ✗ |

MySQL实现示例：

-- 设置事务隔离级别
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
-- 使用间隙锁防止幻读
BEGIN;
SELECT * FROM orders WHERE status = 'PENDING' FOR UPDATE;
-- 此时其他事务无法插入status='PENDING'的记录
COMMIT;

五、分布式系统挑战题

5.1 分布式锁实现

面试题：如何用Redis实现可靠的分布式锁？
Redlock算法要点：

1. 获取当前时间戳
2. 依次向N个Redis节点请求锁
3. 客户端计算获取锁的总耗时，若小于锁过期时间且成功获取N/2+1个锁，则获取成功
4. 锁的实际有效时间 = 初始有效时间 - 获取锁耗时

Redisson实现示例：

Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
RedissonClient redisson = Redisson.create(config);
RLock lock = redisson.getLock("order_lock");
try {
    boolean isLocked = lock.tryLock(10, 30, TimeUnit.SECONDS);
    if (isLocked) {
        // 执行业务逻辑
    }
} finally {
    lock.unlock();
}

5.2 分布式ID生成

方案对比：
| 方案 | 优点 | 缺点 |
|———————-|—————————————|—————————————|
| UUID | 本地生成，无中心化 | 无序，索引效率低 |
| Snowflake | 趋势递增，高性能 | 依赖时钟同步 |
| 数据库自增ID | 简单可靠 | 并发性能差 |
| Leaf | 美团开源，分段号段 | 部署复杂 |

Snowflake核心代码：

public class SnowflakeIdGenerator {
    private final long datacenterId;
    private final long workerId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards");
        }
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & 0xFFF;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;
        return ((timestamp - 1288834974657L) << 22) |
               (datacenterId << 17) |
               (workerId << 12) |
               sequence;
    }
}

六、系统设计方法论

6.1 秒杀系统设计

核心挑战：如何应对10万QPS的秒杀请求？
分层架构：

1. 接入层：Nginx限流（limit_req_zone）
2. 缓存层：Redis预减库存
3. 应用层：异步队列（RabbitMQ）
4. 数据层：数据库分库分表

关键代码：

// Redis库存预减
public boolean preReduceStock(Long productId, int quantity) {
    String key = "seckill:stock:" + productId;
    Long stock = redisTemplate.opsForValue().decrement(key, quantity);
    if (stock < 0) {
        redisTemplate.opsForValue().increment(key, quantity); // 回滚
        return false;
    }
    return true;
}
// 异步处理订单
@RabbitListener(queues = "seckill.order.queue")
public void processOrder(SeckillOrderDTO orderDTO) {
    // 数据库操作
    orderMapper.insert(orderDTO);
    // 更新Redis库存
    redisTemplate.opsForValue().set("seckill:stock:" + orderDTO.getProductId(), 
        stockService.getStock(orderDTO.getProductId()));
}

6.2 短链服务设计

需求分析：

• 输入长URL（如https://example.com/path?query=123）
• 输出短码（如https://s.cn/abc123）
• 支持10亿级短链存储

设计方案：

1. 发号器：使用Snowflake生成唯一ID
2. 编码转换：将62进制ID转换为短码（0-9,a-z,A-Z）
3. 存储优化：
   • 短码→长URL：Redis（热点数据） + MySQL（持久化）
   • 长URL→短码：布隆过滤器防止重复

实现示例：

public class ShortUrlGenerator {
    private static final String CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private final IdGenerator idGenerator;
    public String generate(String longUrl) {
        long id = idGenerator.nextId();
        return encode(id);
    }
    private String encode(long num) {
        StringBuilder sb = new StringBuilder();
        while (num > 0) {
            sb.append(CHARS.charAt((int)(num % 62)));
            num /= 62;
        }
        return sb.reverse().toString();
    }
}

七、面试准备建议

1. 技术深度：对每个知识点掌握”是什么-为什么-怎么做”三层
2. 代码能力：每天练习1-2道LeetCode中等难度算法题
3. 系统设计：熟悉CAP理论、BASE理论等分布式原则
4. 项目复盘：准备3个能体现技术深度的项目案例
5. 模拟面试：使用力扣、牛客网等平台进行全真模拟

推荐学习路径：

1. 基础巩固：JVM原理→并发编程→设计模式
2. 框架进阶：Spring源码→Netty网络编程→MyBatis原理
3. 分布式系统：Zookeeper→Kafka→分布式事务
4. 性能优化：全链路压测→慢查询分析→GC日志解读

本文涵盖的200+个面试场景点，建议结合实际项目经验进行深度思考，形成自己的技术认知体系。面试不仅是知识考核，更是技术视野和解决问题能力的综合展现。