【分布式协作探秘】CRDTs：让数据在分布式世界和谐共存

import java.util.HashMap;
import java.util.Map;

// 状态型G-Counter（只增不减计数器）
class GCounter {
    private Map<String, Integer> counts; // 每个节点的计数器
    private String nodeId; // 当前节点ID

    public GCounter(String nodeId) {
        this.nodeId = nodeId;
        this.counts = new HashMap<>();
        this.counts.put(nodeId, 0);
    }

    // 增加计数器
    public void increment() {
        counts.put(nodeId, counts.getOrDefault(nodeId, 0) + 1);
    }

    // 获取计数器当前值
    public int value() {
        int sum = 0;
        for (int count : counts.values()) {
            sum += count;
        }
        return sum;
    }

    // 合并另一个GCounter的状态
    public void merge(GCounter other) {
        for (Map.Entry<String, Integer> entry : other.counts.entrySet()) {
            String nodeId = entry.getKey();
            int otherCount = entry.getValue();
            int currentCount = counts.getOrDefault(nodeId, 0);
            counts.put(nodeId, Math.max(currentCount, otherCount));
        }
    }

    // 获取当前状态
    public Map<String, Integer> getState() {
        return new HashMap<>(counts);
    }

    // 从状态恢复
    public void setState(Map<String, Integer> state) {
        this.counts = new HashMap<>(state);
    }
}

// 操作型PN-Counter（可增可减计数器）
class PNCounter {
    private GCounter pCounter; // 正数计数器
    private GCounter nCounter; // 负数计数器
    private String nodeId;

    public PNCounter(String nodeId) {
        this.nodeId = nodeId;
        this.pCounter = new GCounter(nodeId);
        this.nCounter = new GCounter(nodeId);
    }

    // 增加计数器
    public void increment() {
        pCounter.increment();
    }

    // 减少计数器
    public void decrement() {
        nCounter.increment();
    }

    // 获取计数器当前值
    public int value() {
        return pCounter.value() - nCounter.value();
    }

    // 合并另一个PNCounter的状态
    public void merge(PNCounter other) {
        pCounter.merge(other.pCounter);
        nCounter.merge(other.nCounter);
    }
}

// 示例使用
public class CRDTExample {
    public static void main(String[] args) {
        // 创建两个节点
        GCounter node1 = new GCounter("node1");
        GCounter node2 = new GCounter("node2");

        // 节点1增加计数器
        node1.increment();
        node1.increment();
        System.out.println("Node1: " + node1.value()); // 输出2

        // 节点2增加计数器
        node2.increment();
        System.out.println("Node2: " + node2.value()); // 输出1

        // 合并状态
        node1.merge(node2);
        node2.merge(node1);

        System.out.println("Node1 after merge: " + node1.value()); // 输出3
        System.out.println("Node2 after merge: " + node2.value()); // 输出3

        // 使用PNCounter
        PNCounter pnCounter1 = new PNCounter("node1");
        PNCounter pnCounter2 = new PNCounter("node2");

        pnCounter1.increment();
        pnCounter1.increment();
        pnCounter2.decrement();

        System.out.println("PNCounter1: " + pnCounter1.value()); // 输出2
        System.out.println("PNCounter2: " + pnCounter2.value()); // 输出-1

        pnCounter1.merge(pnCounter2);
        pnCounter2.merge(pnCounter1);

        System.out.println("PNCounter1 after merge: " + pnCounter1.value()); // 输出1
        System.out.println("PNCounter2 after merge: " + pnCounter2.value()); // 输出1
    }
}