极限5分钟：面试官追问分布式锁实现，应届生手写AQS代码化解危机

原创于 2025-06-05 19:30:01 发布 · 842 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#Java # 面试 # 分布式锁 # AQS # 高并发 # 面试技巧

Java面试场景题专栏收录该内容

9 篇文章

订阅专栏

文章标题：极限5分钟：面试官追问分布式锁实现，应届生手写AQS代码化解危机

文章正文：

在互联网大厂的Java面试中，面试官总是充满智慧与挑战，而应聘者则需要在有限的时间内展示自己的技术实力。今天要讲述的是一名应届生小兰在终面倒计时5分钟的关键时刻，是如何通过手写AQS（AbstractQueuedSynchronizer）的代码，化解了一场突如其来的技术难题，并最终赢得了面试官的认可。

面试场景：终面倒计时5分钟

第一轮提问：分布式锁的基本概念

面试官（严肃）：小兰，你之前提到你熟悉分布式锁的实现，请简单介绍一下分布式锁的基本原理。

小兰（自信）：好的，面试官。分布式锁的核心是解决分布式系统中的并发问题，通常通过共享存储（如Redis、ZooKeeper）来实现。分布式锁需要满足以下特性：

互斥性：同一时间只能有一个客户端持有锁。
可靠性：即使某个客户端崩溃，锁也能自动释放。
可扩展性：支持高并发场景。

常见的分布式锁实现方式有Redis的setNX命令、ZooKeeper的CAS操作等。

面试官（微笑）：不错，看来你对分布式锁的基本概念有比较清晰的理解。那你能说说Redis实现分布式锁的步骤吗？

小兰（思考片刻）：好的，面试官。使用Redis实现分布式锁的步骤大致如下：

调用SETNX命令尝试获取锁。
如果获取成功，设置一个过期时间（如EXPIRE命令），防止锁因持有者崩溃而无法释放。
在加锁和解锁过程中，需要处理网络延迟等问题，避免死锁。

面试官（鼓励）：很好，你对Redis分布式锁的实现细节也很清楚。接下来，我想深入了解一下分布式锁的底层原理。你知道分布式锁是如何与Java中的锁机制关联起来的吗？

第二轮提问：AQS与分布式锁的关系

面试官（好奇）：我们知道，分布式锁的实现通常依赖于底层的锁机制。请问，Java中的AQS（AbstractQueuedSynchronizer）是如何实现锁的？

小兰（思考）：面试官，AQS是Java并发包中的一个核心类，它提供了一个框架，用于构建锁和其他同步组件。AQS的核心思想是通过一个同步状态（state）来管理锁的状态，并维护一个同步队列（CLH队列）来处理线程的阻塞和唤醒。

面试官（追问）：说得很好，那你能不能说说AQS中的公平锁和非公平锁的区别？

小兰（自信）：当然可以，面试官。公平锁和非公平锁的主要区别在于线程获取锁的顺序：

公平锁：按照线程到达的顺序来分配锁，确保先到先得。
非公平锁：允许线程“插队”，如果当前线程竞争锁时状态允许，它可以直接获取锁，而不需要排队。

面试官（微笑）：很好，你对公平锁和非公平锁的理解也很到位。那你能具体描述一下AQS的队列结构吗？

小兰（思考片刻）：AQS的队列结构是一个双向链表，每个节点（Node）表示一个等待锁的线程。线程按照请求锁的顺序依次加入队列，被阻塞的线程会被挂起，直到前驱节点释放锁并唤醒它。

面试官（继续追问）：非常好，那你能手写一段AQS的代码吗？我们可以从acquire方法开始。

第三轮提问：手写AQS代码

小兰（有些紧张但依然自信）：好的，面试官。AQS的核心方法是acquire，它负责线程锁的获取。我可以简单手写一下它的逻辑。

public final void acquire(int arg) {
    // 尝试获取锁，如果获取失败，则进入同步队列
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
        selfInterrupt();
    }
}

// 尝试获取锁，返回true表示获取成功
protected boolean tryAcquire(int arg) {
    return false; // 子类需要实现
}

// 添加线程到等待队列
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

// 将节点加入队列的尾部
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) {
            if (compareAndSetHead(new Node())) {
                tail = head;
            }
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

// 线程获取锁，如果失败则进入等待队列
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt()) {
                interrupted = true;
            }
        }
    } finally {
        if (failed) {
            cancelAcquire(node);
        }
    }
}

面试官（惊讶）：小兰，你居然能手写AQS的核心代码！这段代码展示了你对Java并发底层实现的深刻理解。你不仅掌握了AQS的队列管理，还展示了对线程调度和锁状态管理的清晰认知。非常棒！

小兰（松了一口气）：谢谢面试官的鼓励，这些都是我在学习Java并发时积累的知识。

面试官（微笑）：小兰，你今天的表现非常出色。在短短5分钟内，你不仅回答了分布式锁的实现原理，还通过手写AQS代码展示了你对Java并发底层的理解。我们会综合考虑你的表现，稍后会联系你，给你最终的结果。

结尾

虽然面试时间有限，但小兰凭借扎实的技术功底和临场应变能力，成功化解了面试官的追问。她的表现不仅展示了对分布式锁和AQS的深刻理解，也体现了她对Java并发机制的全面掌握。

附录：问题答案与技术点

问题1：分布式锁的基本原理

分布式锁的作用：解决分布式系统中的并发问题。
核心特性：互斥性、可靠性、可扩展性。
实现方式：Redis的SETNX命令、ZooKeeper的CAS操作等。

问题2：AQS的队列结构与公平锁/非公平锁

AQS队列结构：双向链表，每个节点（Node）代表一个等待锁的线程。
公平锁：按线程到达顺序分配锁。
非公平锁：允许线程“插队”，提升锁的获取效率。

问题3：手写AQS代码

acquire方法：尝试获取锁，失败则进入同步队列。
tryAcquire方法：子类实现，负责锁的具体获取逻辑。
addWaiter方法：将线程加入等待队列。
acquireQueued方法：线程进入等待队列后，尝试获取锁。

业务场景与技术点

分布式锁的业务场景：电商秒杀、分布式事务、高并发场景的资源竞争等。
AQS的核心技术点：同步状态管理、线程调度、公平锁与非公平锁的实现差异。

通过这些技术点，读者可以深入理解分布式锁的实现原理以及AQS在Java并发中的重要作用。