#逻辑时钟 vs 物理时钟

// 物理时钟导致的问题
public class PhysicalTimeProblem {

    public static void main(String[] args) throws InterruptedException {
        long t1 = System.currentTimeMillis();
        Thread.sleep(100);
        long t2 = System.currentTimeMillis();

        System.out.println("时间差: " + (t2 - t1) + "ms");

        // 看起来正常：100ms 延迟

        // 但如果期间发生了 NTP 同步...
        // t2 可能比 t1 更小！
    }
}

// 逻辑时钟的核心：无论物理时间如何，只要消息顺序正确，时间戳就正确
public class LogicalTimeGuarantee {

    public static void main(String[] args) {
        LamportClock clock1 = new LamportClock(1);
        LamportClock clock2 = new LamportClock(2);

        // 无论物理时间如何，以下关系是确定的：
        int t1 = clock1.send();           // P1 发送消息
        int t2 = clock2.receive(t1);      // P2 接收消息

        // t1 < t2 是确定的（因为有消息传递关系）
        System.out.println(t1 < t2);      // 永远为 true
    }
}

public class HybridLogicalClock {

    private long physicalTime;    // 物理时间（毫秒）
    private long logicalTime;     // 逻辑计数器
    private final int nodeId;

    // 本地事件
    public HlcTimestamp tick() {
        long now = System.currentTimeMillis();

        if (now > physicalTime) {
            // 物理时间前进，逻辑时间归零
            physicalTime = now;
            logicalTime = 0;
        } else {
            // 物理时间不变，逻辑时间递增
            logicalTime++;
        }

        return new HlcTimestamp(physicalTime, logicalTime, nodeId);
    }

    // 接收远程消息
    public HlcTimestamp receive(HlcTimestamp received) {
        long now = System.currentTimeMillis();

        // 三者取最大：本地物理时间、接收的物理时间、接收的逻辑时间
        physicalTime = Math.max(now,
            Math.max(physicalTime, received.physicalTime));

        if (physicalTime == received.physicalTime) {
            // 物理时间相同，逻辑时间取 max + 1
            logicalTime = Math.max(logicalTime, received.logicalTime) + 1;
        } else if (physicalTime == now && physicalTime > received.physicalTime) {
            // 本地物理时间前进，逻辑时间归零
            logicalTime = 0;
        } else {
            // 接收的物理时间更大
            logicalTime = Math.max(logicalTime, received.logicalTime) + 1;
        }

        return new HlcTimestamp(physicalTime, logicalTime, nodeId);
    }

    // 比较两个 HLC
    public int compareTo(HlcTimestamp other) {
        if (this.physicalTime != other.physicalTime) {
            return Long.compare(this.physicalTime, other.physicalTime);
        }
        if (this.logicalTime != other.logicalTime) {
            return Long.compare(this.logicalTime, other.logicalTime);
        }
        return Integer.compare(this.nodeId, other.nodeId);
    }
}

// TrueTime 的简化 API
public class TrueTime {

    /**
     * 返回一个时间区间 [earliest, latest]
     * TrueTime 保证：实际物理时间一定在这个区间内
     */
    public static Interval now() {
        // 通过 GPS + 原子钟获取有界误差的时间
        long epsilon = 7;  // 误差 ±7ms
        long now = hardwareClock.now();

        return new Interval(now - epsilon, now + epsilon);
    }

    /**
     * 等待直到物理时间超过给定时间
     * 用于「等待到指定时间再提交事务」
     */
    public static void waitUntil(long targetTime) {
        while (now().latest() < targetTime) {
            // 自旋等待
            Thread.yield();
        }
    }
}