游戏设计之-排行榜处理

前言

我相信大部分人，乃至公司和团队在设计排行榜都考虑的是redis，zadd操作，不需要排序，维护获取，操作都极其简单；

无一例外我也是；

 

 在项目中运营了大量的模板，来处理各个木块的排行榜信息；

统一的会在晚上又一些结算处理；就牵涉一次性拉取，过滤，发放奖励，甚至还有删除操作；

同时为了节约运营陈本，定期还需要对redis里面无效数据进行删除，收缩操作；

 

 

目前redis已经达到6.55g，这只是其中一个平台运营部署；

运营过项目的都知道云redis的费用是非常高昂的；所以就需要定期做一些无用数据的删除操作； 

可是问题来了，随着运营时间的推移，每天早上总能看到如此的异常推送；

就问你揪心不？仔细一查才发现还是数据库相关的操作导致的卡主了；

于是下定决心对排行榜等相关功能进行调整；

削峰

1. 首先就是对数据库的一些删除操作，集中早上5-6点去处理他；这个时候在线玩家最少；处理一些垃圾数据最为合理；基本卡了也不会对玩家的感觉特别强烈反馈；

于是把原来处理的数据移除的代码调整为定时器创建异步任务在凌晨5-6点去处理；

2. 第二步就是为了避免玩家集体拉取数据，并对数据进行操作；考虑重构排行榜代码需求，

排行榜自定义实现

为了模拟排行榜实现的，

首先应该考虑，排行榜数据，既方便查找修改，又方便排序；

那么肯定需要考虑的是

一个map，用于存取和玩家相关积分数据；

一个list，用于排序积分；

首先我们来实现一个积分类

package org.wxd.lang.rank;

import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
import org.wxd.io.ObjectFactory;
import org.wxd.timer.TimeUtil;

import java.util.Comparator;
import java.util.Objects;

/**
 * 排行
 *
 * @author: Troy.Chen(無心道, 15388152619)
 * @version: 2022-12-08 21:27
 **/
@Getter
@Setter
@Accessors(chain = true)
public class RankScore implements Comparable<RankScore> {

    /** 正序 */
    public static final Comparator<RankScore> Sort = (o1, o2) -> {
        if (o1.score != o2.score) {
            return Double.compare(o1.score, o2.score);
        }

        if (o1.scoreTime != o2.scoreTime) {
            /**时间取值要倒叙*/
            return Long.compare(o2.scoreTime, o1.scoreTime);
        }

        return Long.compare(o1.uid, o2.uid);
    };

    /** 倒叙 */
    public static final Comparator<RankScore> BreSort = (o1, o2) -> {
        if (o1.score != o2.score) {
            return Double.compare(o1.score, o2.score);
        }

        if (o1.scoreTime != o2.scoreTime) {
            /**时间取值要倒叙*/
            return Long.compare(o2.scoreTime, o1.scoreTime);
        }

        return Long.compare(o1.uid, o2.uid);
    };

    private long uid;
    private double score;
    private long scoreTime;

    public RankScore setScore(double score) {
        this.score = score;
        this.scoreTime = TimeUtil.currentTimeMillis();
        return this;
    }

    @Override public int compareTo(RankScore o2) {
        return Sort.compare(this, o2);
    }

    public int scoreIntValue() {
        return (int) score;
    }

    public long scoreLongValue() {
        return (long) score;
    }

    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        RankScore rankScore = (RankScore) o;
        return uid == rankScore.uid;
    }

    @Override public int hashCode() {
        return Objects.hash(uid);
    }

    @Override public String toString() {
        return ObjectFactory.stringBuilder(sb -> {
            sb.append(this.getClass().getSimpleName()).append("{");
            sb.append("uid=").append(uid);
            sb.append(", score=").append(score);
            sb.append('}');
        });
    }
}

接下来我实现代码

package test;

import org.junit.Test;
import org.wxd.lang.RandomUtils;
import org.wxd.lang.rank.RankScore;
import org.wxd.system.MarkTimer;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * @author: Troy.Chen(無心道, 15388152619)
 * @version: 2022-12-08 20:48
 **/
public class RankPackTest {

    public class RankPack {
        HashMap<Long, RankScore> rankMap = new HashMap<>();
        List<Long> rankList = new ArrayList<>();

        public void addScore(long uid, double score) {
            /*忽律并发问题 可以自行改为 ConcurrentHashMap*/
            rankMap.computeIfAbsent(uid, l -> {
                RankScore rankScore = new RankScore().setUid(uid).setScore(score);
                /*能到这里初始化，那么list里面必然也没有数据*/
                rankList.add(uid);
                return rankScore;
            });
        }

        public void sort() {
            /*忽律并发问题*/
            rankList.sort((o1, o2) -> {
                RankScore r1 = rankMap.get(o1);
                RankScore r2 = rankMap.get(o2);
                return r1.compareTo(r2);
            });
        }

        public void breSort() {
            /*忽律并发问题*/
            rankList.sort((o1, o2) -> {
                RankScore r1 = rankMap.get(o1);
                RankScore r2 = rankMap.get(o2);
                return r2.compareTo(r1);
            });
        }

    }

    RankPack rankPack = new RankPack();

    @Test
    public void test() {
        init();
        sort();
        sort();
        sort();
        sort2();
        sort2();
        sort2();
    }

    public int randomScore() {
        return RandomUtils.random(100, 10000);
    }

    public void init() {
        MarkTimer build = MarkTimer.build();
        int speed = 1;
        for (int i = 0; i < 300; i++) {
            rankPack.addScore(speed, randomScore());
            speed++;
        }
        rankPack.breSort();
        float v = build.execTime();
        System.out.println(rankPack.getClass().getSimpleName() + " - 数量：" + rankPack.rankMap.size() + ", 全部排序耗时：" + v);
        show();
    }

    public void sort() {
        MarkTimer build = MarkTimer.build();
        rankPack.rankMap.values().forEach(rankScore -> rankScore.setScore(randomScore()));
        rankPack.breSort();
        float v = build.execTime();
        System.out.println(rankPack.getClass().getSimpleName() + " - 数量：" + rankPack.rankMap.size() + ", 全部排序耗时：" + v);
        show();
    }

    public void sort2() {
        MarkTimer build = MarkTimer.build();
        RankScore randomItem = (RankScore) RandomUtils.randomItem(rankPack.rankMap.values());
        randomItem.setScore(randomScore());
        rankPack.breSort();
        float v = build.execTime();
        show();
        int index = rankPack.rankList.indexOf(randomItem.getUid());
        System.out.println(v + " - " + randomItem + " - 当前排名：" + (index + 1));
    }

    public void show() {
//        AtomicInteger atomicInteger = new AtomicInteger();
//        for (int i = 0; i < 10; i++) {
//            Long uid = rankPack.rankList.get(i);
//            RankScore rankScore = rankPack.rankMap.get(uid);
//            System.out.println(rankScore.toString() + " - 排名：" + (i + 1));
//        }
    }

}

运行一下看看效果

 

 视乎性能还可以，等等，我们是不是忽律一个问题，现在排行榜只有300个对象哦，加到3万试试

 

 很明显看得出来，全排序情况下直接翻了30倍左右；单个项修改后排序直接翻了差不多40倍；

到这里或许有很多已经满足需求了，；

 可是我的需求远不止如此，这很明显时间消耗太久了，不知道有么有更为适合的方案来处理性能；

突然想到一个问题，或许了解树结构的同学知道，树装结构数据，在插入数据的时候就已经排序了，并且根据hash索引，性能非常高；

由此我们想到，

 

 那么我们排序很耗时；我能不能不做这个排序操作，通过索引数据结构来达到目的呢？

改造树装结构

我们把刚才hashmap改为treemap

吧list改为treeset试试效果

 

 测试一下，感觉确实是快了很多呢

 

 我们来打印一下数据看看情况

 

 

哦豁，为什么数据不对；

不是我们预期的效果，

然后研究了treeset数据结构就知道，它是排序的，但是他是add的时候排序的，一旦add就不再变更了；

那我们能不能尝试修改的时候先移除，再修改，然后在add呢？

 

我们来改造一下addScore方法块；

  

 

 排序正常了

 

 可以看出运行结构，整体差距不算特别大；

如果考虑并发性能问题；可以把

TreeMap 换成 ConcurrentSkipListMap

TreeSet 换成 ConcurrentSkipListSet

java自带的跳表结构，添加删除查询，都会非常高效；

最后粘贴一下最新的全部测试代码

package test;

import org.junit.Test;
import org.wxd.lang.RandomUtils;
import org.wxd.lang.rank.RankScore;
import org.wxd.system.MarkTimer;

import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ConcurrentSkipListSet;

/**
 * @author: Troy.Chen(無心道, 15388152619)
 * @version: 2022-12-08 20:48
 **/
public class RankPackTest {

    public class RankPack {
        ConcurrentSkipListMap<Long, RankScore> rankMap = new ConcurrentSkipListMap<>();
        ConcurrentSkipListSet<RankScore> rankList = new ConcurrentSkipListSet<>();

        public void addScore(long uid, double score) {
            /*忽律并发问题 可以自行改为 ConcurrentHashMap*/
            RankScore score1 = rankMap.computeIfAbsent(uid, l -> {
                RankScore rankScore = new RankScore().setUid(uid);
                return rankScore;
            });
            rankList.remove(score1);
            score1.setScore(score);
            rankList.add(score1);
        }

//        public void sort() {
//            /*忽律并发问题*/
//            rankList.sort((o1, o2) -> {
//                RankScore r1 = rankMap.get(o1);
//                RankScore r2 = rankMap.get(o2);
//                return r1.compareTo(r2);
//            });
//        }
//
//        public void breSort() {
//            /*忽律并发问题*/
//            rankList.sort((o1, o2) -> {
//                RankScore r1 = rankMap.get(o1);
//                RankScore r2 = rankMap.get(o2);
//                return r2.compareTo(r1);
//            });
//        }

    }

    RankPack rankPack = new RankPack();

    @Test
    public void test() {
        sort();
        sort();
        sort();
        sort();
        sort2();
        sort2();
        sort2();
        sort2();
    }

    public int randomScore() {
        return RandomUtils.random(100, 10000);
    }

    public void sort() {
        MarkTimer build = MarkTimer.build();
        int speed = 1;
        for (int i = 0; i < 30000; i++) {
            rankPack.addScore(speed, randomScore());
            speed++;
        }
//        rankPack.breSort();
        float v = build.execTime();
        System.out.println(rankPack.getClass().getSimpleName() + " - 数量：" + rankPack.rankList.size() + ", 全部排序耗时：" + v);
        show();
    }

    public void sort2() {
        MarkTimer build = MarkTimer.build();
        RankScore randomItem = (RankScore) RandomUtils.randomItem(rankPack.rankMap.values());
        rankPack.addScore(randomItem.getUid(), randomScore());
//        rankPack.breSort();
        float v = build.execTime();
        show();
        int index = 0;
        for (RankScore rankScore : rankPack.rankList) {
            if (rankScore.getUid() == randomItem.getUid()) break;
            index++;
        }
        System.out.println(v + " - " + randomItem + " - 当前排名：" + (index + 1));
    }

    public void show() {
        int i = 0;
        for (RankScore rankScore : rankPack.rankList) {
            System.out.println(rankScore.toString() + " - 排名：" + (i + 1));
            i++;
            if (i >= 10) break;
        }
    }

}

大家如果有兴趣可以自己测试哦；

 好了这里提供集中思路来处理排行榜相关的数据；以及排名功能；

不知道园子里的朋友们，还有没有更好的思路；

听说大家喜欢看，机会是留给有耐心的人