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

事务与批量操作

事务与批量操作

当一次业务变更必须同时检查版本、创建节点并更新数据时,逐条调用 ZooKeeper API 会暴露中间状态。本课用 Transaction 与 multi 把多项写操作组成原子请求,并演示版本冲突时整批回滚。

学习目标

  • 理解 Transaction、multi 与原子提交之间的关系
  • 使用 check、create、setData 和 delete 组合批量写操作
  • 能根据异常与结果判断事务是否提交,并验证失败后没有部分写入

批量操作解决什么问题

普通的 create、setData、delete 每次都是独立请求。若业务要求“版本仍为我刚读取的值时,创建子节点并更新父节点”,拆成三次调用会在请求之间留下竞态窗口。

ZooKeeper.multi(...) 可以把一组操作作为一个事务提交:全部成功才生效,只要其中一项失败,整组都不会部分提交。ZooKeeper.transaction() 返回的 Transaction 只是 multi 之上的构建器,适合链式组织 check、create、setData 与 delete。

Transaction 与 multi 的原子提交路径

用版本检查保护事务

check(path, version) 不修改数据,它要求指定 znode 的当前版本与期望版本一致。把它放在事务开头,相当于乐观锁:若读取数据后已有其他客户端修改节点,提交会得到 BadVersion,后续创建或修改也不会单独落地。

对 setData 和 delete 也应优先传入已读取的版本,而不是长期使用 -1。-1 会匹配任意版本,虽然方便,却会放弃并发冲突检测。

运行一个原子事务

下面示例假定本机已有可访问的 ZooKeeper,地址为 127.0.0.1:2181,项目依赖使用 org.apache.zookeeper:zookeeper:3.9.5。程序先准备测试节点,再提交“检查版本、创建子节点、更新父节点”三项操作,随后故意使用旧版本触发一次回滚。

java
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.OpResult;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class ZkTransactionDemo {
    private static final String ROOT = "/txn-demo";
    private static final String CHILD = ROOT + "/item";
    private static final String ROLLBACK_CHILD = ROOT + "/should-not-exist";

    public static void main(String[] args) throws Exception {
        CountDownLatch connected = new CountDownLatch(1);

        try (ZooKeeper zk = new ZooKeeper("127.0.0.1:2181", 10_000, event -> {
            if (event.getState() == org.apache.zookeeper.Watcher.Event.KeeperState.SyncConnected) {
                connected.countDown();
            }
        })) {
            if (!connected.await(5, TimeUnit.SECONDS)) {
                throw new IllegalStateException("ZooKeeper connection timeout");
            }

            prepare(zk);
            Stat stat = new Stat();
            zk.getData(ROOT, false, stat);
            int versionBeforeCommit = stat.getVersion();

            List<OpResult> results = zk.transaction()
                    .check(ROOT, versionBeforeCommit)
                    .create(CHILD, bytes("created"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT)
                    .setData(ROOT, bytes("committed"), versionBeforeCommit)
                    .commit();

            System.out.println("ops=" + results.size());
            System.out.println("root=" + text(zk.getData(ROOT, false, null)));
            System.out.println("child=" + text(zk.getData(CHILD, false, null)));

            try {
                zk.transaction()
                        .check(ROOT, versionBeforeCommit)
                        .create(ROLLBACK_CHILD, bytes("bad"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT)
                        .commit();
            } catch (KeeperException.BadVersionException e) {
                System.out.println("second=BadVersion");
            }

            System.out.println("rollbackChild=" + (zk.exists(ROLLBACK_CHILD, false) != null));
        }
    }

    private static void prepare(ZooKeeper zk) throws Exception {
        deleteIfExists(zk, ROLLBACK_CHILD);
        deleteIfExists(zk, CHILD);
        Stat root = zk.exists(ROOT, false);
        if (root == null) {
            zk.create(ROOT, bytes("draft"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            zk.setData(ROOT, bytes("draft"), root.getVersion());
        }
    }

    private static void deleteIfExists(ZooKeeper zk, String path) throws Exception {
        Stat stat = zk.exists(path, false);
        if (stat != null) {
            zk.delete(path, stat.getVersion());
        }
    }

    private static byte[] bytes(String value) {
        return value.getBytes(StandardCharsets.UTF_8);
    }

    private static String text(byte[] value) {
        return new String(value, StandardCharsets.UTF_8);
    }
}

预期输出:

text
ops=3
root=committed
child=created
second=BadVersion
rollbackChild=false

第二个事务虽然已经包含 create,但前面的版本检查失败,因此 /txn-demo/should-not-exist 不会出现,这正是原子性的关键验证。

失败时怎么判断

同步 multi 或 Transaction.commit() 成功时会返回与输入操作顺序对应的 OpResult 列表;失败时抛出 KeeperException。若要定位批量请求中的具体失败项,可以读取 KeeperException.getResults() 获取部分结果和错误码,但不能把这些部分结果理解为“前几项已经提交”。

批量事务适合需要共同成败的少量元数据变更,不适合把大量数据塞进一个请求。multi 的请求大小仍受服务端 jute.maxbuffer 等限制;事务越大,冲突和重试成本也越高。

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

目录与阅读设置

阅读设置

17

记录一个想法

事务与批量操作

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

登录哪都通