常见场景解决方案1

 分片数 = 1000 → 每个分片文件约 1GB（1TB ÷ 1000）  
 关键词 K → hash(K) % 1000 → 写入对应分片文件  

输出示例：
 chunk_1.sorted:  
 ("keyword1", 10000)  
 ("keyword2", 9800)  
 ...  

1、初始化：将每个分片文件的第一个关键词（最大值）加入最大堆。

2、循环提取：

  2.1 从最大堆取出当前全局最大值（关键词 K, 次数 C）。

  2.2 若最小堆未满，直接加入；否则，若 C > 堆顶值则替换。

  2.3 若 C ≤ 堆顶值，且最小堆已满，提前终止（后续值更小）。

  2.4 从 K 所属分片读取下一个关键词，更新最大堆。

3、输出结果：最小堆中的关键词即为全局 Top 10。

# 添加/更新成员分数
ZADD leaderboard 100 user1
ZADD leaderboard 95 user2
# 获取排名(从高到低)
ZREVRANK leaderboard user1
# 获取前10名
ZREVRANGE leaderboard 0 9 WITHSCORES

# 分数 = 原始分数 + (1 - 时间戳归一化值)
# 假设时间戳是13位(毫秒)，最大时间戳设为9999999999999(可调整)

# 计算组合分数公式：
组合分数 = 原始分数 * 1e13 + (1e13 - 时间戳)

# Lua脚本示例
local score = tonumber(ARGV[1])
local timestamp = tonumber(ARGV[2])
local combined_score = score * 1e13 + (1e13 - timestamp)
redis.call('ZADD', KEYS[1], combined_score, ARGV[3])

public void addToLeaderboard(String key, String member, double score) {
    long timestamp = System.currentTimeMillis();
    // 保证时间戳不超过12位(可根据需要调整)
    long maxTimestamp = 999999999999L;
    long normalizedTimestamp = Math.min(timestamp, maxTimestamp);
    
    // 组合分数 = 原始分数 * 1e13 + (1e13 - 时间戳)
    double combinedScore = score * 1e13 + (1e13 - normalizedTimestamp);
    
    jedis.zadd(key, combinedScore, member);
}

# 主ZSET存储原始分数
ZADD leaderboard:main 100 user1

# 为每个分数创建时间排序的ZSET
ZADD leaderboard:score:100 1620000000000 user1
ZADD leaderboard:score:100 1620000000001 user2

# 查询时需要两步操作：
# 1. 先获取分数段
ZSCORE leaderboard:main user1
# 2. 再按时间获取同分排名
ZREVRANGE leaderboard:score:100 0 -1 WITHSCORES

LUA脚本：
-- KEYS[1]: 排行榜key
-- ARGV[1]: 原始分数
-- ARGV[2]: 用户ID
-- 返回: 1-成功

local score = tonumber(ARGV[1])
local timestamp = tonumber(ARGV[2] or redis.call('TIME')[1])
local member = ARGV[3]

-- 组合分数计算
local max_timestamp = 9999999999999
timestamp = math.min(timestamp, max_timestamp)
local combined_score = score * 1e13 + (1e13 - timestamp)

redis.call('ZADD', KEYS[1], combined_score, member)
return 1

java:
@Service
public class LeaderboardService {
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    private static final long MAX_TIMESTAMP = 9999999999999L;
    
    // 添加/更新排行榜
    public void addToLeaderboard(String leaderboardKey, String member, double score) {
        long timestamp = System.currentTimeMillis();
        double combinedScore = calculateCombinedScore(score, timestamp);
        
        redisTemplate.opsForZSet().add(
            leaderboardKey, 
            member, 
            combinedScore
        );
    }
    
    // 获取排行榜(分页)
    public List<Ranking> getLeaderboard(String leaderboardKey, int page, int size) {
        long start = (page - 1) * size;
        long end = start + size - 1;
        
        Set<ZSetOperations.TypedTuple<String>> tuples = 
            redisTemplate.opsForZSet().reverseRangeWithScores(leaderboardKey, start, end);
        
        return tuples.stream()
            .map(t -> {
                double combinedScore = t.getScore();
                double originalScore = Math.floor(combinedScore / 1e13);
                long timestamp = (long)(1e13 - (combinedScore % 1e13));
                
                return new Ranking(
                    t.getValue(),
                    originalScore,
                    timestamp,
                    redisTemplate.opsForZSet().reverseRank(leaderboardKey, t.getValue()) + 1
                );
            })
            .collect(Collectors.toList());
    }
    
    private double calculateCombinedScore(double score, long timestamp) {
        long normalizedTimestamp = Math.min(timestamp, MAX_TIMESTAMP);
        return score * 1e13 + (1e13 - normalizedTimestamp);
    }
    
    @Data
    @AllArgsConstructor
    public static class Ranking {
        private String member;
        private double score;
        private long timestamp;
        private long rank;
    }
}