设计一个”全球化/多活”架构（跨地域延迟、数据一致性）

1. 概述

1.1 全球化多活的重要性

全球化多活架构是支撑业务全球化发展的核心基础设施，需要解决：

  • 跨地域延迟：如何降低跨地域访问延迟
  • 数据一致性：如何保证跨地域数据一致性
  • 高可用性：如何保障单地域故障不影响全局
  • 成本控制：如何在保障性能的同时控制成本

1.2 核心挑战

技术挑战：

  • 网络延迟：跨地域网络延迟（50-300ms）
  • 数据同步：跨地域数据同步延迟
  • 数据一致性：最终一致性 vs 强一致性
  • 故障切换：自动故障检测和切换
  • 流量调度：智能流量调度

1.3 本文内容结构

本文将从以下几个方面全面解析全球化多活架构：

  1. 全球化多活概述：架构模式、部署策略
  2. 跨地域延迟优化：CDN、就近接入、数据本地化
  3. 数据一致性方案：强一致性、最终一致性、数据同步
  4. 架构设计：整体架构、模块设计
  5. 技术选型：数据库、缓存、消息队列
  6. 实现方案：完整实现代码
  7. 实战案例：实际应用场景

2. 全球化多活概述

2.1 架构模式

2.1.1 主从模式

架构：

  • 一个主数据中心
  • 多个从数据中心
  • 主中心处理写请求
  • 从中心处理读请求

特点：

  • 优点：数据一致性容易保证
  • 缺点：跨地域写延迟高

2.1.2 多主模式

架构：

  • 多个主数据中心
  • 每个中心都可以处理读写
  • 数据双向同步

特点：

  • 优点：就近访问，延迟低
  • 缺点：数据一致性复杂

2.1.3 单元化模式

架构：

  • 按用户/业务划分单元
  • 每个单元独立部署
  • 单元间数据隔离

特点：

  • 优点：数据隔离，一致性简单
  • 缺点：跨单元访问复杂

2.2 部署策略

2.2.1 地域选择

地域选择原则：

  • 用户分布：根据用户分布选择地域
  • 网络质量：选择网络质量好的地域
  • 成本考虑：考虑地域成本差异

典型部署：

  • 中国：北京、上海、深圳
  • 美国：美东、美西
  • 欧洲：伦敦、法兰克福
  • 亚太：新加坡、东京

2.2.2 数据中心规划

数据中心规划：

  • 核心数据中心：2-3个核心数据中心
  • 边缘数据中心：多个边缘数据中心
  • CDN节点：全球CDN节点

3. 跨地域延迟优化

3.1 CDN加速

3.1.1 CDN架构

CDN架构：

1
2
3
4
5
6
用户请求
    ↓
CDN边缘节点（就近）
    ↓
    ├──→ 缓存命中 → 直接返回
    └──→ 缓存未命中 → 回源获取

3.1.2 CDN配置

Nginx CDN配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# CDN节点配置
server {
    listen 80;
    server_name cdn.example.com;
    
    location / {
        # 缓存配置
        proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=cdn_cache:10m max_size=10g;
        proxy_cache cdn_cache;
        proxy_cache_valid 200 304 12h;
        
        # 回源配置
        proxy_pass http://origin.example.com;
    }
}

3.2 就近接入

3.2.1 DNS智能解析

DNS智能解析：

  • 根据用户IP解析到最近的数据中心
  • 自动故障切换

DNS配置：

1
2
3
4
5
6
7
8
9
# 主域名
example.com    A    192.168.1.100  # 中国
example.com    A    192.168.2.100  # 美国
example.com    A    192.168.3.100  # 欧洲

# 智能解析规则
# 中国用户 → 192.168.1.100
# 美国用户 → 192.168.2.100
# 欧洲用户 → 192.168.3.100

3.2.2 全局负载均衡（GSLB）

GSLB架构：

1
2
3
4
5
6
7
用户请求
    ↓
GSLB（智能DNS）
    ↓
    ├──→ 中国数据中心（北京）
    ├──→ 美国数据中心（美东）
    └──→ 欧洲数据中心（伦敦）

GSLB实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Service
public class GSLBService {
    
    /**
     * 根据用户IP选择最近的数据中心
     */
    public String selectDataCenter(String userIp) {
        // 1. 解析用户IP地理位置
        String region = geoIpService.getRegion(userIp);
        
        // 2. 选择最近的数据中心
        switch (region) {
            case "CN":
                return "beijing.example.com";
            case "US":
                return "us-east.example.com";
            case "EU":
                return "london.example.com";
            default:
                return "beijing.example.com";  // 默认
        }
    }
    
    /**
     * 健康检查
     */
    public String selectHealthyDataCenter(String userIp) {
        List<String> dataCenters = getDataCenters(userIp);
        
        // 选择健康的数据中心
        for (String dataCenter : dataCenters) {
            if (healthCheckService.isHealthy(dataCenter)) {
                return dataCenter;
            }
        }
        
        // 如果都不可用，返回默认
        return getDefaultDataCenter();
    }
}

3.3 数据本地化

3.3.1 数据分片

数据分片策略：

  • 按地域分片：不同地域存储不同数据
  • 按用户分片：用户数据存储在其所在地域
  • 按业务分片：不同业务存储在不同地域

数据分片实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Service
public class DataShardingService {
    
    /**
     * 根据用户ID选择数据分片
     */
    public String selectShard(Long userId, String region) {
        // 1. 优先选择用户所在地域
        String userRegion = getUserRegion(userId);
        if (userRegion != null) {
            return getDataCenterByRegion(userRegion);
        }
        
        // 2. 根据用户ID哈希选择
        int shardIndex = (int) (userId % 3);
        return getDataCenterByIndex(shardIndex);
    }
}

3.3.2 缓存本地化

缓存本地化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Service
public class LocalCacheService {
    
    @Autowired
    private RedisTemplate<String, String> localRedis;
    
    @Autowired
    private RedisTemplate<String, String> globalRedis;
    
    public String get(String key) {
        // 1. 查询本地缓存
        String value = localRedis.opsForValue().get(key);
        if (value != null) {
            return value;
        }
        
        // 2. 查询全局缓存
        value = globalRedis.opsForValue().get(key);
        if (value != null) {
            // 写入本地缓存
            localRedis.opsForValue().set(key, value, 1, TimeUnit.HOURS);
            return value;
        }
        
        // 3. 查询数据库
        value = loadFromDatabase(key);
        if (value != null) {
            // 写入缓存
            localRedis.opsForValue().set(key, value, 1, TimeUnit.HOURS);
            globalRedis.opsForValue().set(key, value, 1, TimeUnit.HOURS);
        }
        
        return value;
    }
}

4. 数据一致性方案

4.1 强一致性

4.1.1 两阶段提交（2PC）

2PC流程：

  1. 准备阶段：协调者询问所有参与者是否可以提交
  2. 提交阶段：如果所有参与者同意，协调者通知提交

实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Service
public class TwoPhaseCommitService {
    
    /**
     * 两阶段提交
     */
    @Transactional
    public void commit(Transaction transaction) {
        // 1. 准备阶段
        List<Boolean> prepareResults = new ArrayList<>();
        for (DataCenter dataCenter : dataCenters) {
            boolean prepared = dataCenter.prepare(transaction);
            prepareResults.add(prepared);
        }
        
        // 2. 如果所有参与者都准备成功，进入提交阶段
        if (prepareResults.stream().allMatch(r -> r)) {
            for (DataCenter dataCenter : dataCenters) {
                dataCenter.commit(transaction);
            }
        } else {
            // 回滚
            for (DataCenter dataCenter : dataCenters) {
                dataCenter.rollback(transaction);
            }
        }
    }
}

问题：

  • 性能差（需要等待所有参与者）
  • 单点故障（协调者故障）
  • 阻塞（参与者故障会阻塞）

4.1.2 三阶段提交（3PC）

3PC流程：

  1. CanCommit阶段：询问是否可以提交
  2. PreCommit阶段：预提交
  3. DoCommit阶段：执行提交

改进：

  • 增加超时机制
  • 减少阻塞时间

4.2 最终一致性

4.2.1 数据同步

数据同步策略：

  • 主从同步：主中心写，从中心同步
  • 双向同步：多主双向同步
  • 异步同步：异步数据同步

4.2.2 主从同步

MySQL主从同步：

1
2
3
4
5
6
7
8
9
10
11
-- 主库配置
[mysqld]
server-id = 1
log-bin = mysql-bin
binlog-format = ROW

-- 从库配置
[mysqld]
server-id = 2
relay-log = mysql-relay-bin
read-only = 1

主从同步配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
-- 在主库创建复制用户
CREATE USER 'repl'@'%' IDENTIFIED BY 'password';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';

-- 在从库配置
CHANGE MASTER TO
    MASTER_HOST='master.example.com',
    MASTER_USER='repl',
    MASTER_PASSWORD='password',
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=154;

START SLAVE;

4.2.3 双向同步

MySQL双向同步：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
-- 节点1配置
[mysqld]
server-id = 1
log-bin = mysql-bin
binlog-format = ROW
auto-increment-offset = 1
auto-increment-increment = 2

-- 节点2配置
[mysqld]
server-id = 2
log-bin = mysql-bin
binlog-format = ROW
auto-increment-offset = 2
auto-increment-increment = 2

双向同步配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
-- 节点1配置从节点2
CHANGE MASTER TO
    MASTER_HOST='node2.example.com',
    MASTER_USER='repl',
    MASTER_PASSWORD='password',
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=154;

-- 节点2配置从节点1
CHANGE MASTER TO
    MASTER_HOST='node1.example.com',
    MASTER_USER='repl',
    MASTER_PASSWORD='password',
    MASTER_LOG_FILE='mysql-bin.000001',
    MASTER_LOG_POS=154;

4.3 数据冲突解决

4.3.1 冲突检测

冲突检测：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Service
public class ConflictDetectionService {
    
    /**
     * 检测数据冲突
     */
    public boolean hasConflict(DataRecord record1, DataRecord record2) {
        // 1. 检查版本号
        if (!record1.getVersion().equals(record2.getVersion())) {
            return true;
        }
        
        // 2. 检查时间戳
        if (Math.abs(record1.getUpdateTime() - record2.getUpdateTime()) > 1000) {
            return true;
        }
        
        return false;
    }
}

4.3.2 冲突解决策略

冲突解决策略：

  • 时间戳优先：最新时间戳优先
  • 版本号优先：高版本号优先
  • 最后写入优先：最后写入的数据优先
  • 业务规则：根据业务规则解决

冲突解决实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Service
public class ConflictResolutionService {
    
    /**
     * 解决数据冲突
     */
    public DataRecord resolveConflict(DataRecord record1, DataRecord record2) {
        // 策略1：时间戳优先
        if (record1.getUpdateTime() > record2.getUpdateTime()) {
            return record1;
        } else if (record2.getUpdateTime() > record1.getUpdateTime()) {
            return record2;
        }
        
        // 策略2：版本号优先
        if (record1.getVersion() > record2.getVersion()) {
            return record1;
        } else if (record2.getVersion() > record1.getVersion()) {
            return record2;
        }
        
        // 策略3：最后写入优先
        return record1.getUpdateTime() >= record2.getUpdateTime() ? record1 : record2;
    }
}

5. 架构设计

5.1 整体架构

5.1.1 架构图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
全球用户
    ↓
CDN（全球节点）
    ↓
GSLB（智能DNS）
    ↓
    ├──→ 中国数据中心（北京）
    │       ├──→ 应用服务
    │       ├──→ 数据库（主）
    │       └──→ 缓存、消息队列
    ├──→ 美国数据中心（美东）
    │       ├──→ 应用服务
    │       ├──→ 数据库（从）
    │       └──→ 缓存、消息队列
    └──→ 欧洲数据中心（伦敦）
            ├──→ 应用服务
            ├──→ 数据库（从）
            └──→ 缓存、消息队列
    ↓
数据同步（主从同步、双向同步）

5.1.2 架构说明

接入层：

  • CDN：全球CDN节点
  • GSLB：智能DNS，就近路由

服务层：

  • 应用服务：多地域部署
  • 数据库：主从复制
  • 缓存：本地缓存 + 全局缓存
  • 消息队列：跨地域消息同步

数据层：

  • 数据同步：主从同步、双向同步
  • 数据一致性：最终一致性

5.2 模块设计

5.2.1 路由服务

路由服务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Service
public class RoutingService {
    
    @Autowired
    private GSLBService gslbService;
    
    /**
     * 路由到最近的数据中心
     */
    public String routeToNearestDataCenter(String userIp) {
        return gslbService.selectHealthyDataCenter(userIp);
    }
    
    /**
     * 路由到主数据中心（写操作）
     */
    public String routeToMasterDataCenter() {
        return getMasterDataCenter();
    }
    
    /**
     * 路由到从数据中心（读操作）
     */
    public String routeToSlaveDataCenter(String userIp) {
        return gslbService.selectHealthyDataCenter(userIp);
    }
}

5.2.2 数据同步服务

数据同步服务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Service
public class DataSyncService {
    
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    
    /**
     * 同步数据到其他数据中心
     */
    public void syncData(String dataCenter, DataRecord record) {
        // 发送到消息队列
        kafkaTemplate.send("data-sync", dataCenter, JSON.toJSONString(record));
    }
    
    /**
     * 处理数据同步
     */
    @KafkaListener(topics = "data-sync", groupId = "data-sync-processor")
    public void processDataSync(String dataCenter, String message) {
        DataRecord record = JSON.parseObject(message, DataRecord.class);
        
        // 同步到目标数据中心
        syncToDataCenter(dataCenter, record);
    }
}

6. 技术选型

6.1 数据库选型

6.1.1 MySQL主从

MySQL主从：

  • 主库处理写请求
  • 从库处理读请求
  • 主从同步延迟

6.1.2 MySQL双向同步

MySQL双向同步：

  • 多主模式
  • 双向数据同步
  • 冲突解决

6.1.3 分布式数据库

分布式数据库：

  • TiDB：分布式MySQL
  • CockroachDB：分布式SQL数据库
  • Spanner：Google的全球分布式数据库

6.2 缓存选型

6.2.1 Redis主从

Redis主从：

  • 主节点写
  • 从节点读
  • 主从同步

6.2.2 Redis Cluster

Redis Cluster：

  • 分布式集群
  • 数据分片
  • 高可用

6.3 消息队列选型

6.3.1 Kafka跨地域

Kafka跨地域：

  • 多地域Kafka集群
  • 跨地域消息同步
  • 消息复制

7. 实现方案

7.1 读写分离

7.1.1 数据源配置

多数据源配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    public DataSource masterDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://master-beijing:3306/db");
        config.setUsername("root");
        config.setPassword("password");
        return new HikariDataSource(config);
    }
    
    @Bean
    public DataSource slaveDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://slave-beijing:3306/db");
        config.setUsername("root");
        config.setPassword("password");
        return new HikariDataSource(config);
    }
    
    @Bean
    public DataSource routingDataSource() {
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("master", masterDataSource());
        dataSourceMap.put("slave", slaveDataSource());
        
        RoutingDataSource routingDataSource = new RoutingDataSource();
        routingDataSource.setTargetDataSources(dataSourceMap);
        routingDataSource.setDefaultTargetDataSource(masterDataSource());
        
        return routingDataSource;
    }
}

7.1.2 路由数据源

路由数据源实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class RoutingDataSource extends AbstractRoutingDataSource {
    
    @Override
    protected Object determineCurrentLookupKey() {
        // 根据上下文决定使用哪个数据源
        String dataSourceType = DataSourceContext.getDataSourceType();
        return dataSourceType != null ? dataSourceType : "master";
    }
}

public class DataSourceContext {
    
    private static final ThreadLocal<String> DATA_SOURCE_TYPE = new ThreadLocal<>();
    
    public static void setDataSourceType(String type) {
        DATA_SOURCE_TYPE.set(type);
    }
    
    public static String getDataSourceType() {
        return DATA_SOURCE_TYPE.get();
    }
    
    public static void clear() {
        DATA_SOURCE_TYPE.remove();
    }
}

7.1.3 AOP切面

数据源切换切面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Aspect
@Component
public class DataSourceAspect {
    
    @Around("@annotation(ReadOnly)")
    public Object switchDataSource(ProceedingJoinPoint point) throws Throwable {
        try {
            // 切换到从库
            DataSourceContext.setDataSourceType("slave");
            return point.proceed();
        } finally {
            DataSourceContext.clear();
        }
    }
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly {
}

7.2 数据同步

7.2.1 Binlog同步

Binlog同步服务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Service
public class BinlogSyncService {
    
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    
    /**
     * 监听Binlog事件
     */
    @EventListener
    public void handleBinlogEvent(BinlogEvent event) {
        // 发送到消息队列
        kafkaTemplate.send("binlog-sync", JSON.toJSONString(event));
    }
}

@Component
public class BinlogConsumer {
    
    @KafkaListener(topics = "binlog-sync", groupId = "binlog-sync-processor")
    public void processBinlog(String message) {
        BinlogEvent event = JSON.parseObject(message, BinlogEvent.class);
        
        // 同步到其他数据中心
        syncToDataCenters(event);
    }
    
    private void syncToDataCenters(BinlogEvent event) {
        List<String> dataCenters = getDataCenters();
        for (String dataCenter : dataCenters) {
            if (!dataCenter.equals(getCurrentDataCenter())) {
                syncToDataCenter(dataCenter, event);
            }
        }
    }
}

8. 故障切换

8.1 健康检查

8.1.1 健康检查服务

健康检查：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Service
public class HealthCheckService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    /**
     * 检查数据中心健康状态
     */
    public boolean isHealthy(String dataCenter) {
        String key = "health:check:" + dataCenter;
        String status = redisTemplate.opsForValue().get(key);
        return "healthy".equals(status);
    }
    
    @Scheduled(fixedRate = 5000)  // 每5秒检查一次
    public void checkHealth() {
        List<String> dataCenters = getDataCenters();
        for (String dataCenter : dataCenters) {
            boolean healthy = doHealthCheck(dataCenter);
            String key = "health:check:" + dataCenter;
            redisTemplate.opsForValue().set(key, healthy ? "healthy" : "unhealthy", 
                10, TimeUnit.SECONDS);
        }
    }
    
    private boolean doHealthCheck(String dataCenter) {
        try {
            // 检查数据库连接
            boolean dbHealthy = checkDatabase(dataCenter);
            
            // 检查应用服务
            boolean appHealthy = checkApplication(dataCenter);
            
            return dbHealthy && appHealthy;
        } catch (Exception e) {
            return false;
        }
    }
}

8.2 故障切换

8.2.1 自动切换

故障切换服务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Service
public class FailoverService {
    
    @Autowired
    private HealthCheckService healthCheckService;
    
    @Autowired
    private GSLBService gslbService;
    
    @Scheduled(fixedRate = 10000)  // 每10秒检查一次
    public void checkAndFailover() {
        String masterDataCenter = getMasterDataCenter();
        
        // 检查主数据中心健康状态
        if (!healthCheckService.isHealthy(masterDataCenter)) {
            // 切换到备用数据中心
            String backupDataCenter = getBackupDataCenter();
            if (healthCheckService.isHealthy(backupDataCenter)) {
                switchToDataCenter(backupDataCenter);
            }
        }
    }
    
    private void switchToDataCenter(String dataCenter) {
        // 1. 更新GSLB配置
        gslbService.setMasterDataCenter(dataCenter);
        
        // 2. 通知所有服务
        notifyServices(dataCenter);
        
        // 3. 记录切换日志
        log.warn("故障切换：切换到数据中心 {}", dataCenter);
    }
}

9. 实战案例

9.1 案例1：全球电商平台

9.1.1 架构设计

架构：

  • 中国：主数据中心（北京）
  • 美国：从数据中心（美东）
  • 欧洲：从数据中心（伦敦）

数据同步：

  • 主从同步
  • 异步复制
  • 最终一致性

9.1.2 实现方案

读写分离：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Service
public class ProductService {
    
    @ReadOnly
    public Product getProduct(Long productId) {
        // 从从库读取
        return productMapper.selectById(productId);
    }
    
    public void updateProduct(Product product) {
        // 写入主库
        productMapper.updateById(product);
        
        // 异步同步到其他数据中心
        dataSyncService.syncData("all", product);
    }
}

9.2 案例2：全球内容平台

9.2.1 架构设计

架构：

  • 多主模式：每个地域都是主数据中心
  • 双向同步：数据双向同步
  • 冲突解决：时间戳优先

9.2.2 实现方案

多主同步：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Service
public class ContentService {
    
    public void publishContent(Content content) {
        // 写入本地数据中心
        contentMapper.insert(content);
        
        // 同步到其他数据中心
        for (String dataCenter : getOtherDataCenters()) {
            dataSyncService.syncData(dataCenter, content);
        }
    }
}

10. 总结

10.1 核心要点

  1. 架构模式：主从模式、多主模式、单元化模式
  2. 延迟优化：CDN、就近接入、数据本地化
  3. 数据一致性：强一致性、最终一致性、冲突解决
  4. 故障切换：健康检查、自动切换
  5. 技术选型：数据库、缓存、消息队列

10.2 关键设计

  1. GSLB：智能DNS，就近路由
  2. 数据同步：主从同步、双向同步
  3. 读写分离：主库写、从库读
  4. 故障切换：自动检测和切换
  5. 冲突解决：时间戳、版本号优先

10.3 最佳实践

  1. 就近接入：用户访问最近的数据中心
  2. 数据本地化：用户数据存储在其所在地域
  3. 最终一致性：接受最终一致性，提高性能
  4. 监控告警：实时监控，及时告警

相关文章：