阿里Java面试现场，面试官与面试者真实录！

阿里Java面试现场实录

面试官：请解释Java中的HashMap实现原理，包括扩容机制和线程安全问题。

面试者：
HashMap基于数组+链表/红黑树实现。存储时通过hash(key) & (n-1)确定数组下标（n为数组长度）。当链表长度超过8且数组长度≥64时，链表转为红黑树；元素少于6时回退为链表。

扩容触发条件是元素数超过阈值（容量×负载因子，默认0.75）。扩容时创建新数组（原容量×2），重新计算所有元素位置。由于采用尾插法（JDK8+），避免了JDK7头插法的死循环问题，但仍非线程安全。例如并发put可能导致数据覆盖，或扩容时形成循环链表。线程安全场景需用ConcurrentHashMap或Collections.synchronizedMap。

---

面试官：synchronized和ReentrantLock有什么区别？如何选择？

面试者：
主要区别有三点：

1. 实现机制：

   • synchronized是JVM级关键字，通过monitorenter/monitorexit指令实现
   • ReentrantLock是API级锁，基于AQS队列

2. 功能特性：

   • ReentrantLock支持公平锁、可中断锁、超时获取锁（tryLock）
   • synchronized仅支持非公平锁

3. 锁释放：

   • synchronized自动释放（代码块结束或异常）
   • ReentrantLock需手动unlock()，通常在finally中执行

选择建议：

• 简单同步场景用synchronized（代码简洁，JVM自动优化）
• 需要高级功能（如限时等待）时选ReentrantLock

---

面试官：写一个单例模式，要求线程安全且防止反射破坏。

面试者：

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {
        // 防止反射调用构造器
        if (instance != null) {
            throw new RuntimeException("禁止反射创建实例");
        }
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

关键点：

• 双重检测锁（DCL）保证线程安全
• volatile防止指令重排序（避免返回未初始化对象）
• 私有构造器内校验拦截反射攻击

---

面试官：MySQL的InnoDB如何解决幻读问题？

面试者：
InnoDB通过Next-Key Lock（间隙锁+记录锁）解决幻读：

1. 快照读（SELECT）：基于MVCC多版本并发控制，通过ReadView保证一致性视图
2. 当前读（SELECT FOR UPDATE）：
   • 在RR隔离级别下，对扫描范围加间隙锁
   • 例如执行SELECT * FROM t WHERE id > 100 FOR UPDATE时，锁定(100, +∞)区间
   • 阻塞其他事务在该区间的插入操作，从而消除幻读

---

面试官（算法题）：给定链表头节点，每K个节点一组进行反转。
示例：输入 1→2→3→4→5, K=2，输出 2→1→4→3→5

面试者：

public ListNode reverseKGroup(ListNode head, int k) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode pre = dummy, end = dummy;
    
    while (end.next != null) {
        // 定位本组尾节点
        for (int i = 0; i < k && end != null; i++) end = end.next;
        if (end == null) break;
        
        // 切割子链表
        ListNode start = pre.next;
        ListNode nextGroup = end.next;
        end.next = null;
        
        // 反转本组并拼接
        pre.next = reverse(start);
        start.next = nextGroup;
        
        // 重置指针
        pre = start;
        end = pre;
    }
    return dummy.next;
}

private ListNode reverse(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

时间复杂度：$O(n)$，空间复杂度：$O(1)$

---