《后端架构设计·分布式与数据一致性》2.1 物理时钟、NTP 与时钟漂移的可见后果

$ go test ./internal/platform/clock/ -run TestMonotonicSurvivesWallRollback -v -count=1
=== RUN   TestMonotonicSurvivesWallRollback
    drift_test.go:19: wall delta=-2s mono delta=3s
--- PASS: TestMonotonicSurvivesWallRollback (0.00s)

// file: internal/platform/clock/drift.go
// tier: L1
// verify: go test ./internal/platform/clock/ -count=1
package clock

import "time"

// SimulatedClock keeps separate wall and monotonic tracks so a test can move
// the wall clock backwards while monotonic time keeps increasing.
type SimulatedClock struct {
	wall time.Time
	mono time.Duration
}

// NewSimulatedClock starts both tracks at start.
func NewSimulatedClock(start time.Time) *SimulatedClock {
	return &SimulatedClock{wall: start}
}

// Now returns the wall reading.
func (c *SimulatedClock) Now() time.Time { return c.wall }

// Mono returns elapsed monotonic time since construction.
func (c *SimulatedClock) Mono() time.Duration { return c.mono }

// Advance moves wall and monotonic time together, like real elapsed time.
func (c *SimulatedClock) Advance(d time.Duration) {
	c.wall = c.wall.Add(d)
	c.mono += d
}

// StepWall moves only the wall clock, modelling an NTP correction.
func (c *SimulatedClock) StepWall(d time.Duration) { c.wall = c.wall.Add(d) }

// Exchange records the four NTP timestamps.
type Exchange struct {
	T1, T2, T3, T4 time.Time
}

// Estimate is the NTP offset and round-trip delay estimate.
type Estimate struct {
	Offset time.Duration
	Delay  time.Duration
}

// EstimateExchange applies the NTP offset formula. The answer is exact only
// when the two one-way delays are equal; residual error is (d1-d2)/2.
func EstimateExchange(e Exchange) Estimate {
	offset := (e.T2.Sub(e.T1) + e.T3.Sub(e.T4)) / 2
	delay := e.T4.Sub(e.T1) - e.T3.Sub(e.T2)
	return Estimate{Offset: offset, Delay: delay}
}

// LWWRegister is a last-write-wins register keyed by wall-clock timestamps.
type LWWRegister struct {
	Value  string
	Writer string
	TS     time.Time
}

// Set accepts value only if ts is strictly newer than the stored timestamp.
func (r *LWWRegister) Set(value, writer string, ts time.Time) bool {
	if !ts.After(r.TS) {
		return false
	}
	r.Value, r.Writer, r.TS = value, writer, ts
	return true
}

// Merge returns the register that wins between two replicas.
func (r LWWRegister) Merge(other LWWRegister) LWWRegister {
	switch {
	case other.TS.After(r.TS):
		return other
	case r.TS.After(other.TS):
		return r
	case other.Writer > r.Writer:
		return other
	default:
		return r
	}
}

// file: internal/platform/clock/drift_test.go
// tier: L1
// verify: go test ./internal/platform/clock/ -run TestNTPOffset -count=1
package clock

import (
	"testing"
	"time"
)

func TestNTPOffset(t *testing.T) {
	base := time.Date(2026, 10, 26, 20, 0, 0, 0, time.UTC)
	tests := []struct {
		name       string
		oneWayIn   time.Duration
		oneWayOut  time.Duration
		serverSkew time.Duration
		wantOffset time.Duration
		wantDelay  time.Duration
	}{
		{"symmetric", 10 * time.Millisecond, 10 * time.Millisecond, 2 * time.Second,
			2 * time.Second, 20 * time.Millisecond},
		{"asymmetric", 30 * time.Millisecond, 10 * time.Millisecond, 2 * time.Second,
			2*time.Second + 10*time.Millisecond, 40 * time.Millisecond},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t1 := base
			t2 := t1.Add(tc.oneWayIn).Add(tc.serverSkew)
			t3 := t2.Add(time.Millisecond)
			t4 := t3.Add(tc.oneWayOut).Add(-tc.serverSkew)
			got := EstimateExchange(Exchange{T1: t1, T2: t2, T3: t3, T4: t4})
			if got.Offset != tc.wantOffset || got.Delay != tc.wantDelay {
				t.Fatalf("offset=%v delay=%v", got.Offset, got.Delay)
			}
		})
	}
}

$ go test ./internal/platform/clock/ -run TestNTPOffset -v -count=1
=== RUN   TestNTPOffset/symmetric
    drift_test.go:64: offset=2s delay=20ms
=== RUN   TestNTPOffset/asymmetric
    drift_test.go:64: offset=2.01s delay=40ms
--- PASS: TestNTPOffset (0.00s)

$ go test ./internal/platform/clock/ -run TestLWWLosesLaterWrite -v -count=1
=== RUN   TestLWWLosesLaterWrite
    drift_test.go:92: paid ts=2026-10-26T20:00:05Z cancelled ts=2026-10-26T20:00:02.5Z merged=PAID writer=node-a
--- PASS: TestLWWLosesLaterWrite (0.00s)