diff --git a/game-server/app/services/rankService.ts b/game-server/app/services/rankService.ts
index 714a2aa9f..a2157aab2 100644
--- a/game-server/app/services/rankService.ts
+++ b/game-server/app/services/rankService.ts
@@ -1,14 +1,12 @@
-import { KeyName, KeyNameParam, RankParam, GuildRankParam, RoleRankInfo, GuildLeader, LineupParam, myIdInter, GeneralRankParam, ValueConfig, GuildRankInfo, RoleAndGuildRankInfo } from "../domain/rank";
+import { KeyName, KeyNameParam, RankParam, GuildRankParam, RoleRankInfo, LineupParam, myIdInter, GeneralRankParam, ValueConfig, GuildRankInfo, RoleAndGuildRankInfo } from "../domain/rank";
 import { getInfoKeyByRedisKey, ROLE_SELECT, GUILD_SELECT, REDIS_KEY, HERO_SELECT, COMPOSE_FIELD_TYPE, KEY_TO_COMPOSE_FIELD, getRedisKeyByRankType, COUNTER, RANK_TYPE, PUSH_ROUTE } from "../consts";
 import { redisClient, delKeys } from "./redisService";
 import { RoleType, RoleModel } from "../db/Role";
 import { GuildType, GuildModel } from "../db/Guild";
 import { HeroModel, HeroType, HeroUpdate } from "../db/Hero";
-import { PVPConfigModel } from "../db/SystemConfig";
 import { PvpDefenseModel } from "../db/PvpDefense";
 import { gameData } from "../pubUtils/data";
 import { getSeconds, nowSeconds } from "../pubUtils/timeUtil";
-import { getWorldChannelSid } from "./chatChannelService";
 import { BackendSession, pinus } from "pinus";
 import { RankFirstModel, RankFirstType, RankFirstUpdateParam } from "../db/RankFirst";
 import { getRandSingleEelm } from "../pubUtils/util";
@@ -355,7 +353,7 @@ export class Rank {
         } else {
             newScore = await this.updateRankScoreEncode(myId, scores, isInc)
         }
-        this.checkMyRankAndPush(myId, oldScore, newScore);
+        this.checkFirstRankAndPush(myId, oldScore, newScore);
         return newScore;
     }
 
@@ -904,51 +902,77 @@ export class Rank {
         return timestamp
     }
 
-    private async checkMyRankAndPush(myId: myIdInter, oldScore: number, newScore: number) {
+    private async getFirstUserInfo(myId: myIdInter) {
+        const info = await redisClient().hgetAsync(this.infoKey, this.composeFields(this.infoKey, myId));
+        const playerInfo = JSON.parse(info);
+
+        if (this.infoKey == REDIS_KEY.USER_INFO) {
+            let userInfo = new RankParam(playerInfo);
+            return { userInfo }
+        } else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
+            let guildInfo = new GuildRankInfo(playerInfo);
+            return { guildInfo }
+        }
+        return false
+    }
+
+    // 首通
+    private async checkFirstRankAndPush(myId: myIdInter, oldScore: number, newScore: number) {
         let ts = this;
         if (ts.isInit) return;
-        let myRank = await this.getMyRank(myId);
-        // console.log('*******', ts.key, myRank, newScore, oldScore);
-        if (myRank == 1 && newScore > oldScore) {
-            let serverId = this.keyName.serverId;
-            let sid = await getWorldChannelSid(serverId);
-            let dicRank = gameData.rank.find(({ id }) => {
-                let redisKey = getRedisKeyByRankType(id);
-                return redisKey == ts.key
-            });
-            // console.log('*******', dicRank);
-            if(dicRank) {
-                let r = new Rank(ts.key, { serverId }, false, 1);
-                let ranks = await r.getRankByRange();
-                let rankFirstRecs: (RankFirstType & { status: number })[] = [];
-                if(ranks.length > 0 && ranks[0]) {
-                    let userInfo: RankParam, guildInfo: GuildRankParam;
-                    if(ranks[0] instanceof RoleRankInfo) {
-                        userInfo = ranks[0];
-                    }
-                    if(ranks[0] instanceof GuildRankInfo) {
-                        guildInfo = ranks[0];
-                    }
 
-                    for(let [id, { rankId, condition }] of gameData.generalRankReward) {
-                        // console.log(rankId, dicRank.id, oldScore, condition, newScore);
-                        if(dicRank.id == rankId && oldScore < condition && newScore >= condition) {
-                            let rankFirstRec = await RankFirstModel.createRankFirst(serverId, id, rankId, { userInfo, guildInfo });
-                            if(rankFirstRec && getSeconds(rankFirstRec.createdAt) == getSeconds(rankFirstRec.updatedAt)) {
-                                let roleServers = pinus.app.getServersByType('role');
-                                for(let server of roleServers) {
-                                    pinus.app.rpc.role.roleRemote.setRankFirst.toServer(server.id, rankFirstRec);
-                                }
-                                rankFirstRecs.push({ ... rankFirstRec, status: 1});
-                            }
-                        }
-                    }
-                }
-                if(rankFirstRecs.length > 0) {
-                    await sendMessageToServerWithSuc(serverId, PUSH_ROUTE.RANK_TOP_UPDATE, { ranks: rankFirstRecs }, true);
+        let serverId = this.keyName.serverId;
+        let dicRank = gameData.rank.find(({ id }) => {
+            let redisKey = getRedisKeyByRankType(id);
+            return redisKey == ts.key
+        });
+        if(!dicRank) return;
+
+        let infos = await this.getFirstUserInfo(myId);
+        if(!infos) return;
+
+        let { userInfo, guildInfo } = infos
+        let rankFirstRecs: (RankFirstType & { status: number })[] = [];
+        for(let [id, { rankId, condition }] of gameData.generalRankReward) {
+            // console.log(rankId, dicRank.id, oldScore, condition, newScore);
+            let hasRankFirst = await getRankFirstRewardById(serverId, id);
+            if(!hasRankFirst && dicRank.id == rankId && oldScore < condition && newScore >= condition) {
+                let rankFirstRec = await RankFirstModel.createRankFirst(serverId, id, rankId, { userInfo, guildInfo });
+                if(rankFirstRec && getSeconds(rankFirstRec.createdAt) == getSeconds(rankFirstRec.updatedAt)) {
+                    await setRankFirst(rankFirstRec);
+                    rankFirstRecs.push({ ... rankFirstRec, status: 1});
                 }
             }
         }
+            
+        if(rankFirstRecs.length > 0) {
+            await sendMessageToServerWithSuc(serverId, PUSH_ROUTE.RANK_TOP_UPDATE, { ranks: rankFirstRecs }, true);
+        }
+    }
+}
+
+/**
+ * 从其他服获取首通信息
+ * @param serverId 
+ * @param id dic_zyz_rankingType的id
+ * @returns 
+ */
+async function getRankFirstRewardById(serverId: number, id: number) {
+    let rankFirst: RankFirstType;
+    if(pinus.app.getServerType() == 'role') {
+        rankFirst = pinus.app.get('rankFirstRewards').get(serverId)?.get(id);
+    } else {
+        let roleServers = pinus.app.getServersByType('role');
+        let server = getRandSingleEelm(roleServers);
+        rankFirst = await pinus.app.rpc.role.roleRemote.getRankFirstById.toServer(server.id, serverId, id);
+    }
+    return rankFirst;
+}
+
+async function setRankFirst(rankFirstRec: RankFirstType) {
+    let roleServers = pinus.app.getServersByType('role');
+    for(let server of roleServers) {
+        pinus.app.rpc.role.roleRemote.setRankFirst.toServer(server.id, rankFirstRec);
     }
 }
 
@@ -1120,14 +1144,7 @@ export async function getGeneralRank(role: RoleType & { rankReceived: number[] }
     let result: (RankFirstUpdateParam & {status: number})[] = [];
 
     for (let [id, { rankId: type } ] of gameData.generalRankReward) {
-        let rankFirst: RankFirstType;
-        if(pinus.app.getServerType() == 'role') {
-            rankFirst = pinus.app.get('rankFirstRewards').get(serverId)?.get(id);
-        } else {
-            let roleServers = pinus.app.getServersByType('role');
-            let server = getRandSingleEelm(roleServers);
-            rankFirst = await pinus.app.rpc.role.roleRemote.getRankFirstById.toServer(server.id, serverId, id);
-        }
+        let rankFirst = await getRankFirstRewardById(serverId, id);
        
         if(rankFirst) {
             let status = rankReceived.includes(id)?RANK_FIRST_REWARD_STATUS.RECEIVED: RANK_FIRST_REWARD_STATUS.CAN_RECEIVE;