高级

分布式系统

Distributed System Design

理解 CAP 理论，掌握分布式事务、一致性协议、数据分片策略。

1CAP 理论

分布式系统的三个基本特性，最多只能同时满足两个： **C (Consistency)**：一致性 - 所有节点同一时刻数据相同 **A (Availability)**：可用性 - 每个请求都能得到响应 **P (Partition Tolerance)**：分区容错 - 网络分区时系统仍能运行 **Web3 视角**： - 区块链选择 CP：强一致性（共识），牺牲部分可用性（出块时间） - Layer2 选择 AP：高可用（快速确认），牺牲即时一致性（等待上链）

2分布式事务

跨服务数据一致性解决方案：

example.go

1// Saga 模式实现
2type Saga struct {
3    steps []SagaStep
4}
5 
6type SagaStep struct {
7    Name       string
8    Action     func(ctx context.Context) error
9    Compensate func(ctx context.Context) error
10}
11 
12func (s *Saga) Execute(ctx context.Context) error {
13    executed := make([]SagaStep, 0)
14 
15    for _, step := range s.steps {
16        if err := step.Action(ctx); err != nil {
17            // 执行补偿
18            for i := len(executed) - 1; i >= 0; i-- {
19                if compErr := executed[i].Compensate(ctx); compErr != nil {
20                    log.Printf("compensate %s failed: %v", executed[i].Name, compErr)
21                }
22            }
23            return fmt.Errorf("step %s failed: %w", step.Name, err)
24        }
25        executed = append(executed, step)
26    }
27    return nil
28}
29 
30// 示例：NFT 购买 Saga
31func NewNFTPurchaseSaga(order *Order) *Saga {
32    return &Saga{
33        steps: []SagaStep{
34            {
35                Name:       "LockNFT",
36                Action:     func(ctx context.Context) error { return lockNFT(order.NFTID) },
37                Compensate: func(ctx context.Context) error { return unlockNFT(order.NFTID) },
38            },
39            {
40                Name:       "DeductBalance",
41                Action:     func(ctx context.Context) error { return deductBalance(order) },
42                Compensate: func(ctx context.Context) error { return refundBalance(order) },
43            },
44            {
45                Name:       "TransferNFT",
46                Action:     func(ctx context.Context) error { return transferNFT(order) },
47                Compensate: func(ctx context.Context) error { return revertNFTTransfer(order) },
48            },
49        },
50    }
51}

3分布式锁

Redis 分布式锁实现：

example.go

1type DistributedLock struct {
2    client *redis.Client
3    key    string
4    value  string
5    ttl    time.Duration
6}
7 
8func (l *DistributedLock) Lock(ctx context.Context) (bool, error) {
9    l.value = uuid.New().String()
10    return l.client.SetNX(ctx, l.key, l.value, l.ttl).Result()
11}
12 
13func (l *DistributedLock) Unlock(ctx context.Context) error {
14    script := redis.NewScript(`
15        if redis.call("GET", KEYS[1]) == ARGV[1] then
16            return redis.call("DEL", KEYS[1])
17        else
18            return 0
19        end
20    `)
21    _, err := script.Run(ctx, l.client, []string{l.key}, l.value).Result()
22    return err
23}
24 
25// 看门狗续期
26func (l *DistributedLock) StartWatchdog(ctx context.Context) {
27    ticker := time.NewTicker(l.ttl / 3)
28    go func() {
29        for {
30            select {
31            case <-ticker.C:
32                l.client.Expire(ctx, l.key, l.ttl)
33            case <-ctx.Done():
34                return
35            }
36        }
37    }()
38}

核心要点

•理解 CAP 取舍，根据业务选型
•优先使用最终一致性方案
•分布式锁要有超时和续期机制
•Saga 比 2PC 更适合微服务

真实案例

→跨链桥：分布式事务保证资产安全
→多链钱包：最终一致性同步余额
→链上治理：分布式投票计数

高并发设计安全设计

1CAP 理论

2分布式事务

跨服务数据一致性解决方案：

example.go

1// Saga 模式实现
2type Saga struct {
3    steps []SagaStep
4}
5 
6type SagaStep struct {
7    Name       string
8    Action     func(ctx context.Context) error
9    Compensate func(ctx context.Context) error
10}
11 
12func (s *Saga) Execute(ctx context.Context) error {
13    executed := make([]SagaStep, 0)
14 
15    for _, step := range s.steps {
16        if err := step.Action(ctx); err != nil {
17            // 执行补偿
18            for i := len(executed) - 1; i >= 0; i-- {
19                if compErr := executed[i].Compensate(ctx); compErr != nil {
20                    log.Printf("compensate %s failed: %v", executed[i].Name, compErr)
21                }
22            }
23            return fmt.Errorf("step %s failed: %w", step.Name, err)
24        }
25        executed = append(executed, step)
26    }
27    return nil
28}
29 
30// 示例：NFT 购买 Saga
31func NewNFTPurchaseSaga(order *Order) *Saga {
32    return &Saga{
33        steps: []SagaStep{
34            {
35                Name:       "LockNFT",
36                Action:     func(ctx context.Context) error { return lockNFT(order.NFTID) },
37                Compensate: func(ctx context.Context) error { return unlockNFT(order.NFTID) },
38            },
39            {
40                Name:       "DeductBalance",
41                Action:     func(ctx context.Context) error { return deductBalance(order) },
42                Compensate: func(ctx context.Context) error { return refundBalance(order) },
43            },
44            {
45                Name:       "TransferNFT",
46                Action:     func(ctx context.Context) error { return transferNFT(order) },
47                Compensate: func(ctx context.Context) error { return revertNFTTransfer(order) },
48            },
49        },
50    }
51}

3分布式锁

Redis 分布式锁实现：

example.go

1type DistributedLock struct {
2    client *redis.Client
3    key    string
4    value  string
5    ttl    time.Duration
6}
7 
8func (l *DistributedLock) Lock(ctx context.Context) (bool, error) {
9    l.value = uuid.New().String()
10    return l.client.SetNX(ctx, l.key, l.value, l.ttl).Result()
11}
12 
13func (l *DistributedLock) Unlock(ctx context.Context) error {
14    script := redis.NewScript(`
15        if redis.call("GET", KEYS[1]) == ARGV[1] then
16            return redis.call("DEL", KEYS[1])
17        else
18            return 0
19        end
20    `)
21    _, err := script.Run(ctx, l.client, []string{l.key}, l.value).Result()
22    return err
23}
24 
25// 看门狗续期
26func (l *DistributedLock) StartWatchdog(ctx context.Context) {
27    ticker := time.NewTicker(l.ttl / 3)
28    go func() {
29        for {
30            select {
31            case <-ticker.C:
32                l.client.Expire(ctx, l.key, l.ttl)
33            case <-ctx.Done():
34                return
35            }
36        }
37    }()
38}