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

分布式屏障

分布式屏障

分布式屏障用于让多个进程在同一个阶段点等待:要么由一个协调者统一放行,要么等所有参与者都到齐后一起开始并在结束时再次汇合。本节用 Curator 的 DistributedBarrier 与 DistributedDoubleBarrier 完成两种常见同步模式。

学习目标

  • 区分单屏障与双屏障各自控制的同步边界。
  • 使用 DistributedBarrier 实现“先等待、后统一放行”。
  • 使用 DistributedDoubleBarrier 实现“全部到齐后开始、全部完成后离开”。

两种屏障解决不同的同步问题

DistributedBarrier 有一个显式屏障状态:协调者先设置屏障,参与者调用 waitOnBarrier() 后阻塞,协调者移除屏障时所有等待者继续执行。它适合维护窗口结束、配置准备完成后统一启动等“由外部条件决定何时放行”的场景。 :contentReference[oaicite:3]{index=3}

DistributedDoubleBarrier 不需要单独的放行者。每个参与者先调用 enter(),达到 memberQty 阈值后进入工作阶段;工作完成后再调用 leave(),直到成员完成离开同步。Curator 文档说明 memberQty 是触发阈值而不是参与者上限,因此业务上仍应自行控制实际参与集合。 :contentReference[oaicite:4]{index=4}

模式 开始条件 结束条件 典型用途
DistributedBarrier 协调者移除屏障 无第二次同步 统一开闸、等待外部条件
DistributedDoubleBarrier 达到成员阈值 成员共同离开 批处理、并行计算阶段同步

单屏障与双屏障的进程同步时序

用一个程序覆盖两种屏障

下面程序使用三个运行模式:controller 设置单屏障并在 5 秒后移除,worker 等待该屏障,double 参加固定阈值的双屏障。项目需要已经引入 Curator Framework 与 Recipes,并保证所有进程连接到同一个 ZooKeeper 集群和相同路径。

java
import java.util.concurrent.TimeUnit;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.barriers.DistributedBarrier;
import org.apache.curator.framework.recipes.barriers.DistributedDoubleBarrier;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class BarrierDemo {
    private static final String SINGLE_PATH = "/demo/start-barrier";
    private static final String DOUBLE_PATH = "/demo/double-barrier";

    public static void main(String[] args) throws Exception {
        if (args.length == 0) {
            throw new IllegalArgumentException("模式必须是 controller、worker 或 double");
        }

        String mode = args[0];
        String connect = args.length > 1 ? args[1] : "127.0.0.1:2181";
        String name = args.length > 2 ? args[2] : "worker";
        int members = args.length > 3 ? Integer.parseInt(args[3]) : 3;

        try (CuratorFramework client = CuratorFrameworkFactory.newClient(
                connect, new ExponentialBackoffRetry(1000, 3))) {
            client.start();
            if (!client.blockUntilConnected(5, TimeUnit.SECONDS)) {
                throw new IllegalStateException("ZooKeeper 连接超时");
            }

            if ("controller".equals(mode)) {
                runController(client);
            } else if ("worker".equals(mode)) {
                runWorker(client, name);
            } else if ("double".equals(mode)) {
                runDoubleBarrier(client, name, members);
            } else {
                throw new IllegalArgumentException("未知模式: " + mode);
            }
        }
    }

    private static void runController(CuratorFramework client) throws Exception {
        DistributedBarrier barrier = new DistributedBarrier(client, SINGLE_PATH);
        barrier.setBarrier();
        System.out.println("屏障已设置,5 秒后统一放行");
        Thread.sleep(5000);
        barrier.removeBarrier();
        System.out.println("屏障已移除");
    }

    private static void runWorker(CuratorFramework client, String name) throws Exception {
        DistributedBarrier barrier = new DistributedBarrier(client, SINGLE_PATH);
        System.out.println(name + " 正在等待屏障");
        barrier.waitOnBarrier();
        System.out.println(name + " 已通过屏障");
    }

    private static void runDoubleBarrier(
            CuratorFramework client, String name, int members) throws Exception {
        DistributedDoubleBarrier barrier =
                new DistributedDoubleBarrier(client, DOUBLE_PATH, members);

        System.out.println(name + " 等待全部成员进入");
        if (!barrier.enter(15, TimeUnit.SECONDS)) {
            throw new IllegalStateException(name + " 等待进入屏障超时");
        }

        System.out.println(name + " 开始任务");
        Thread.sleep(1000);
        System.out.println(name + " 任务完成,等待其他成员");

        if (!barrier.leave(15, TimeUnit.SECONDS)) {
            throw new IllegalStateException(name + " 等待离开屏障超时");
        }
        System.out.println(name + " 已完成双屏障");
    }
}

预期结果

text
controller 模式:先输出“屏障已设置,5 秒后统一放行”,随后输出“屏障已移除”
worker 模式:屏障存在时停在“<NAME> 正在等待屏障”,屏障移除后输出“<NAME> 已通过屏障”
double 模式:达到成员阈值前停在“<NAME> 等待全部成员进入”,到齐后进入任务阶段

验证单屏障统一放行

先启动协调者,再在 5 秒窗口内启动两个参与者。下面假设 <PATH> 是已经包含业务类和 Curator 依赖的实际 classpath;不同构建工具生成的路径会不同。

bash
CP="<PATH>"
java -cp "$CP" BarrierDemo controller 127.0.0.1:2181 &
sleep 1
java -cp "$CP" BarrierDemo worker 127.0.0.1:2181 A &
java -cp "$CP" BarrierDemo worker 127.0.0.1:2181 B &
wait

预期输出

text
屏障已设置,5 秒后统一放行
A 正在等待屏障
B 正在等待屏障
屏障已移除
A 已通过屏障
B 已通过屏障

后台进程的打印顺序可能略有不同,但关键验收点不变:A 和 B 的“已通过屏障”必须发生在“屏障已移除”之后。如果参与者在屏障设置前就调用 waitOnBarrier(),它可能直接通过,因此单屏障的操作顺序本身就是协议的一部分。

验证双屏障阶段同步

双屏障不需要协调者,启动三个参与进程即可。所有进程使用相同路径,并把阈值都设置为 3;如果某个进程传入不同阈值,参与者对“何时到齐”的判断就不再一致。

bash
CP="<PATH>"
java -cp "$CP" BarrierDemo double 127.0.0.1:2181 A 3 &
java -cp "$CP" BarrierDemo double 127.0.0.1:2181 B 3 &
java -cp "$CP" BarrierDemo double 127.0.0.1:2181 C 3 &
wait

预期输出

text
A 等待全部成员进入
B 等待全部成员进入
C 等待全部成员进入
<NAME> 开始任务
<NAME> 任务完成,等待其他成员
<NAME> 已完成双屏障

<NAME> 会分别替换为 A、B、C,同一阶段内三者的具体打印顺序不保证一致。验收重点是:不足 3 个成员时没有进程进入任务阶段;成员到齐后都能开始;最后所有进程都能从 leave() 返回。

屏障异常时不要无限等待

屏障是同步点,也天然可能成为全局阻塞点。生产代码应为双屏障使用带超时的 enter、leave,并把超时视为一次协调失败,而不是继续假装本轮任务成功。DistributedDoubleBarrier 在连接丢失时也可能从进入或离开操作抛出异常。 :contentReference[oaicite:5]{index=5}

单屏障同样要设计“谁负责移除、协调者崩溃后如何恢复”的策略。若屏障只由一个临时进程负责解除,应配合超时、健康检查或人工恢复流程,否则一个未清理的屏障路径就可能让所有参与者长期停在等待状态。

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

目录与阅读设置

阅读设置

17

记录一个想法

分布式屏障

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

登录哪都通