服务注册与分布式协调 / 系统课时

读写锁与多锁

读写锁与多锁

分布式锁的难点不只是“互斥”,还包括读多写少场景下的并发能力,以及一次操作需要同时占有多个资源时的原子性。本课使用 Curator 的读写锁和多锁配方,重点建立锁顺序、超时与会话失效三条安全边界。

学习目标

  • 区分分布式读锁与写锁的并发语义和升级限制
  • 使用 InterProcessReadWriteLock 控制跨进程读写临界区
  • 使用 InterProcessMultiLock 联合获取多个资源锁并规避死锁

读写锁的并发语义

InterProcessReadWriteLock 在同一路径上提供一对关联锁。没有写者时,多个进程可以同时持有读锁;写锁是独占的,持有期间其他读者和写者都必须等待。Curator 的实现支持可重入,因此同一持有线程可以按规则重复获取已经持有的锁。

一个容易忽略的边界是锁升级:持有写锁的线程可以再取得读锁,从而实现“写锁降级为读锁”的控制流程;反过来,已经持有读锁再等待写锁不会成功。需要写权限时,应先释放读锁,再按统一协议重新竞争写锁。

分布式读写锁与多资源联合加锁关系

使用读写锁保护临界区

以下完整示例通过第二个参数选择 read 或 write 模式。多个 read 进程可以同时获得锁,而 write 进程需要等待现有读者释放。示例使用有界等待,避免连接异常或竞争激烈时无限阻塞。

java
import java.util.concurrent.TimeUnit;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessReadWriteLock;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class ReadWriteLockDemo {
    public static void main(String[] args) throws Exception {
        String connectString = args.length > 0 ? args[0] : "127.0.0.1:2181";
        String mode = args.length > 1 ? args[1] : "read";
        try (CuratorFramework client = CuratorFrameworkFactory.newClient(
                connectString, new ExponentialBackoffRetry(1000, 3))) {
            client.start();
            if (!client.blockUntilConnected(10, TimeUnit.SECONDS)) {
                throw new IllegalStateException("ZooKeeper connection timeout");
            }
            InterProcessReadWriteLock rwLock =
                    new InterProcessReadWriteLock(client, "/locks/catalog");
            InterProcessLock lock = "write".equalsIgnoreCase(mode)
                    ? rwLock.writeLock()
                    : rwLock.readLock();
            boolean acquired = lock.acquire(5, TimeUnit.SECONDS);
            if (!acquired) {
                System.out.println(mode + " lock timeout");
                return;
            }
            try {
                System.out.println(mode + " lock acquired");
                // 模拟受保护的读取或写入操作。
                Thread.sleep(2000);
            } finally {
                lock.release();
                System.out.println(mode + " lock released");
            }
        }
    }
}

预期输出

text
read lock acquired
read lock released

以 write 参数运行时,输出中的 read 会变为 write。多个实例并发执行时,具体等待时长会不同,但任一时刻只能有一个写者进入临界区。

联合获取多个资源锁

跨账户转账、同时修改两块分片或迁移两个资源时,业务往往要求“要么同时拿到全部锁,要么一个也不保留”。InterProcessMultiLock 可以把多把 InterProcessLock 作为一个整体获取;如果获取过程中失败,它会释放已经取得的锁。

下面是片段示例,复用前一节已经启动并连接成功的 CuratorFramework client。资源路径先排序,再构造多锁,确保所有参与者使用同一获取顺序。

java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.apache.curator.framework.recipes.locks.InterProcessMultiLock;

List<String> paths = new ArrayList<>(Arrays.asList(
        "/locks/account-b",
        "/locks/account-a"));
paths.sort(String::compareTo);
InterProcessMultiLock multiLock = new InterProcessMultiLock(client, paths);
boolean acquired = multiLock.acquire(5, TimeUnit.SECONDS);
if (!acquired) {
    System.out.println("multi lock timeout");
} else {
    try {
        System.out.println("acquired " + paths);
        // 只有全部资源锁都持有时,才执行跨资源事务。
    } finally {
        multiLock.release();
    }
}

预期输出

text
acquired [/locks/account-a, /locks/account-b]

如果任一资源在 5 秒内无法取得,则预期结果为 multi lock timeout,已经获取的锁会被释放。实际竞争结果取决于其他客户端是否正在持锁。

死锁风险来自不一致的锁顺序

多锁并不会自动消除所有死锁条件。假设客户端 A 先拿 account-a 再等 account-b,客户端 B 却先拿 account-b 再等 account-a,使用无限等待就可能形成循环等待。最有效的工程规则是把资源标识排序后再加锁,并为整组获取设置总超时。

另外,不要把“拿到 ZooKeeper 锁”理解成对外部系统的永久所有权。连接进入 SUSPENDED 时应停止启动新的高风险操作;会话进入 LOST 后必须认为锁已经丢失。涉及资金、库存或唯一写入时,还应结合数据库事务、版本号或 fencing token 防止失效持有者继续提交结果。

读写锁用于提高“读多写少”场景的并发度,多锁用于保证一组资源的联合占有;两者都必须以统一路径、统一顺序、有限等待和连接状态处理为前提,否则锁本身会从协调工具变成新的故障源。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

读写锁与多锁

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通