1
package seqlock
2

3
import (
4
    "runtime"
5
    "sync/atomic"
6
)
7

8
// SeqLock 用序列号保护共享数据的乐观读
9
type SeqLock struct {
10
    seq atomic.Int32 // 序列号，偶数=无写入，奇数=写入中
11
    mu  atomic.Bool  // 写者互斥锁
12
}
13

14
// ReadBegin 返回当前序列号，读者开始读前调用
15
func (sl *SeqLock) ReadBegin() int32 {
16
    for {
17
        seq := sl.seq.Load()
18
        if seq%2 == 0 {
19
            return seq // 偶数，可以读
20
        }
21
        // 奇数说明有人在写，短暂让出 CPU 后重试
22
        runtime.Gosched()
23
    }
24
}
25

26
// ReadRetry 检查读到的数据是否一致
27
// 返回 true 表示需要重试
28
func (sl *SeqLock) ReadRetry(seq int32) bool {
29
    return sl.seq.Load() != seq // 序列号变了就要重试
30
}
31

32
// WriteLock 获取写锁，递增序列号为奇数
33
func (sl *SeqLock) WriteLock() {
34
    // 自旋等待其他写者释放
35
    for !sl.mu.CompareAndSwap(false, true) {
36
        runtime.Gosched()
37
    }
38
    sl.seq.Add(1) // 偶数 → 奇数，表示写入中
39
}
40

41
// WriteUnlock 递增序列号为偶数，释放写锁
42
func (sl *SeqLock) WriteUnlock() {
43
    sl.seq.Add(1) // 奇数 → 偶数，写入完成
44
    sl.mu.Store(false)
45
}
46

47
// Read 执行一次乐观读，自动重试直到读到一致数据
48
func Read[T any](sl *SeqLock, readFn func() T) T {
49
    for {
50
        seq := sl.ReadBegin()
51
        val := readFn()        // 读取共享数据
52
        if !sl.ReadRetry(seq) {
53
            return val         // 序列号没变，数据一致
54
        }
55
        // 序列号变了，重试
56
    }
57
}

1
// SeqLock：用序列号实现乐观读
2
class SeqLock {
3
  private seq = 0;  // 序列号
4

5
  // 读开始：返回当前序列号（偶数才可用）
6
  readBegin(): number {
7
    while (this.seq % 2 !== 0) {
8
      // 奇数表示有写入，等一下再试
9
    }
10
    return this.seq;
11
  }
12

13
  // 读重试检查：序列号变了就需要重试
14
  readRetry(startSeq: number): boolean {
15
    return this.seq !== startSeq;
16
  }
17

18
  // 写加锁：序列号变奇数
19
  writeLock(): void {
20
    this.seq++; // 偶数 → 奇数
21
  }
22

23
  // 写解锁：序列号变偶数
24
  writeUnlock(): void {
25
    this.seq++; // 奇数 → 偶数
26
  }
27
}
28

29
// 使用示例：保护一个统计数据结构
30
interface Stats {
31
  requestCount: number;
32
  errorCount: number;
33
  avgLatency: number;
34
}
35

36
const lock = new SeqLock();
37
let stats: Stats = { requestCount: 0, errorCount: 0, avgLatency: 0 };
38

39
// 读者：乐观读，自动重试
40
function readStats(): Stats {
41
  for (;;) {
42
    const seq = lock.readBegin();
43
    const snapshot = { ...stats }; // 拷贝一份
44
    if (!lock.readRetry(seq)) {
45
      return snapshot; // 序列号一致，数据有效
46
    }
47
    // 不一致，重试
48
  }
49
}
50

51
// 写者：更新统计数据
52
function updateStats(errors: number, latency: number): void {
53
  lock.writeLock();
54
  stats.requestCount++;
55
  stats.errorCount += errors;
56
  stats.avgLatency = (stats.avgLatency + latency) / 2;
57
  lock.writeUnlock();
58
}