diff --git a/game-server/app.ts b/game-server/app.ts
index 66f7c98e5..f6c38cff0 100644
--- a/game-server/app.ts
+++ b/game-server/app.ts
@@ -30,6 +30,7 @@ import { resResult, genCode } from './app/pubUtils/util';
 import { errlogger, infologger, loadLogger } from './app/util/logger';
 import { connectThinkingData, getTire } from './app/services/sdkService';
 import { loadGmDb } from './app/db';
+import { loadActivities } from './app/services/activity/activityRemoteService';
 
 const filePath = (_pinus as any).FILEPATH;
 filePath.MASTER = '/config/master';
@@ -143,26 +144,6 @@ app.configure(ALL_ENVS, 'gm', function () {
     app.filter(tokenFilter(app));
 });
 
-app.configure(ALL_ENVS, 'systimer', function () {
-    app.event.on('start_all', async (servers) => {
-        redisService.redisSubScribe();
-        await redisService.initAllRank();
-        await timeTaskService.init();
-    });
-});
-
-app.configure(ALL_ENVS, 'chat', function() {
-    app.event.on('start_all', () => {
-        getTire();
-    });
-});
-
-app.configure(ALL_ENVS, 'activity', function () {
-    app.event.on('start_all', () => {
-        app.rpc.activity.activityRemote.loadActivities.toServer(app.getServerId());
-    });
-});
-
 
 function errorHandler(err: Error, msg: any, resp: any,
     session: FrontendOrBackendSession, cb: HandlerCallback) {
@@ -192,6 +173,30 @@ export function globalErrorHandler(err: Error, msg: any, resp: any,
 async function treatStartLogic(app: _pinus.Application) {
     await connectDb(app);
     console.log('treatStartLogic', app.getServerType());
+    
+    if(app.getServerType() == 'systimer') {
+        redisService.redisSubScribe();
+        timeTaskService.init();
+    }
+    if(app.getServerType() == 'chat') {
+        getTire();
+    }
+    if(app.getServerType() == 'activity') {
+        loadActivities();
+    }
+    treatStartMainten(app);
+
+    if(app.isMaster()) {
+        redisService.initAllRank();
+        redisService.readDataBase();
+        redisService.clearComBtlQueue();
+        redisService.clearChannelServers();
+        updateTeamStatus(COM_TEAM_STATUS.DEFAULT, COM_TEAM_STATUS.LOOSE);
+        updateTeamStatus(COM_TEAM_STATUS.FIGHTING, COM_TEAM_STATUS.LOOSE);
+    }
+}
+
+async function treatStartMainten(app: _pinus.Application) {
     if(app.getServerType() == 'systimer') {
         // 维护信息
         await timeTaskService.initMaintenance();
@@ -286,11 +291,6 @@ if (app.isMaster()) {
     app.event.on('start_all', () => {
         // 全部服务器启动完毕后初始化 redis 数据
         redisService.checkConnectors();
-        redisService.readDataBase();
-        redisService.clearComBtlQueue();
-        redisService.clearChannelServers();
-        updateTeamStatus(COM_TEAM_STATUS.DEFAULT, COM_TEAM_STATUS.LOOSE);
-        updateTeamStatus(COM_TEAM_STATUS.FIGHTING, COM_TEAM_STATUS.LOOSE);
     });
 }
 
diff --git a/game-server/app/servers/activity/remote/activityRemote.ts b/game-server/app/servers/activity/remote/activityRemote.ts
index 3f56c702e..076cbcfe2 100644
--- a/game-server/app/servers/activity/remote/activityRemote.ts
+++ b/game-server/app/servers/activity/remote/activityRemote.ts
@@ -2,12 +2,12 @@ import { Application, ChannelService, HandlerService, } from 'pinus';
 import { ActivityModel, ActivityModelType } from '../../../db/Activity';
 import { ServerlistModel } from '../../../db/Serverlist';
 import { reloadResources } from '../../../pubUtils/data';
-import { _getActivitiesByType, _getActivityById, _getActivities, _getActivitiesByServerId } from '../../../services/activity/activityService';
 import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 import { taflush } from '../../../services/sdkService';
 import { ActivityInRemote } from '../../../domain/activityField/activityField';
 import { errlogger } from '../../../util/logger';
 import { ActivityGroupModel } from '../../../db/ActivityGroup';
+import { deleteActivities, loadActivities, saveActivitiesToGroup, updateActivities, _getActivityById, _getActivitiesByType, _getActivities, _getActivitiesByServerId } from '../../../services/activity/activityRemoteService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -22,10 +22,6 @@ export class ActivityRemote {
     }
 
     private channelService: ChannelService;
-    private activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
-    private activities: Map<number, ActivityInRemote> = new Map(); // activityId => activity
-    private activityByType: Map<number, Map<number, number[]>> = new Map(); // serverId => type => activityId[];
-    private groupToServer: Map<number, number[]> = new Map(); // group => serverId[];
 
     /**
      * 重载json资源
@@ -38,86 +34,19 @@ export class ActivityRemote {
         }
     }
 
-    private clearData() {
-        this.activityByServer.clear();
-        this.activities.clear();
-        this.activityByType.clear();
-        this.groupToServer.clear();
-    }
-
     public async loadActivities() {
         try {
-            this.clearData();
-            let activityGroup = await ActivityGroupModel.findAllActivityGroup();
-            for(let { groupId, serverIds } of activityGroup) {
-                for(let serverId of serverIds) {
-                    if(!this.groupToServer.has(groupId)) {
-                        this.groupToServer.set(groupId, []);
-                    }
-                    this.groupToServer.get(groupId).push(serverId);
-                }
-            }
-    
-            let activities = await ActivityModel.findOpenAndComingActivityes();
-            let activityIds: number[] = [];
-            for(let activity of activities) {
-                this.activities.set(activity.activityId, new ActivityInRemote(activity));
-                activityIds.push(activity.activityId);
-            }
-            this.setActivityTypeAndServer();
-    
-            this.app.set('activityByServer', this.activityByServer);
-            this.app.set('activityByType', this.activityByType);
-            this.app.set('activities', this.activities);
-            this.app.set('groupToServer', this.groupToServer);
             // console.log('****** loadActivities')
+            await loadActivities();
         } catch(e) {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
     }
 
-    private setActivityTypeAndServer() {
-        this.activityByServer.clear();
-        this.activityByType.clear();
-
-        for(let [_, activity] of this.activities) {
-            let servers = this.groupToServer.get(activity.groupId)||[];
-            for(let serverId of servers) {
-                if(!this.activityByServer.has(serverId)) {
-                    this.activityByServer.set(serverId, []);
-                }
-                this.activityByServer.get(serverId).push(activity.activityId);
-
-                if(!this.activityByType.has(serverId)) {
-                    this.activityByType.set(serverId, new Map());
-                }
-                if(!this.activityByType.get(serverId).has(activity.type)) {
-                    this.activityByType.get(serverId).set(activity.type, []);
-                }
-                this.activityByType.get(serverId).get(activity.type).push(activity.activityId);
-            }
-        }
-
-        this.app.set('activityByServer', this.activityByServer);
-        this.app.set('activityByType', this.activityByType);
-        this.app.set('activities', this.activities);
-        this.app.set('groupToServer', this.groupToServer);
-    }
-
     public async updateActivities(activities: ActivityInRemote[]) {
         try {
             // console.log('******* activities', activities)
-            let activityIds: number[] = [];
-            for(let activity of activities) {
-                this.activities.set(activity.activityId, activity);
-                activityIds.push(activity.activityId);
-            }
-            this.setActivityTypeAndServer();
-    
-            this.app.set('activityByServer', this.activityByServer);
-            this.app.set('activityByType', this.activityByType);
-            this.app.set('activities', this.activities);
-            this.app.set('groupToServer', this.groupToServer);
+            updateActivities(activities);
         } catch(e) {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
@@ -125,15 +54,7 @@ export class ActivityRemote {
 
     public async deleteActivities(activityIds: number[]) {
         try {
-            for(let activityId of activityIds) {
-                this.activities.delete(activityId);
-            }
-            this.setActivityTypeAndServer();
-    
-            this.app.set('activityByServer', this.activityByServer);
-            this.app.set('activityByType', this.activityByType);
-            this.app.set('activities', this.activities);
-            this.app.set('groupToServer', this.groupToServer);
+            deleteActivities(activityIds);
         } catch(e) {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
@@ -141,13 +62,7 @@ export class ActivityRemote {
 
     public async saveGroupToServer(groupId: number, serverIds: number[]) {
         try {
-            this.groupToServer.set(groupId, serverIds);
-            this.setActivityTypeAndServer();
-    
-            this.app.set('activityByServer', this.activityByServer);
-            this.app.set('activityByType', this.activityByType);
-            this.app.set('activities', this.activities);
-            this.app.set('groupToServer', this.groupToServer);
+            this.saveGroupToServer(groupId, serverIds);
         } catch(e) {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
@@ -155,12 +70,7 @@ export class ActivityRemote {
 
     public async saveActivitiesToGroup(groupId: number, activities: number[]) {
         try {
-            for(let activityId of activities) {
-                if(this.activities.get(activityId)) {
-                    this.activities.get(activityId).groupId = groupId;
-                }
-            }
-            this.setActivityTypeAndServer();
+            saveActivitiesToGroup(groupId, activities);
         } catch(e) {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
diff --git a/game-server/app/services/activity/activityRemoteService.ts b/game-server/app/services/activity/activityRemoteService.ts
new file mode 100644
index 000000000..834221888
--- /dev/null
+++ b/game-server/app/services/activity/activityRemoteService.ts
@@ -0,0 +1,152 @@
+import { Application, ChannelService, HandlerService, pinus, } from 'pinus';
+import { ActivityModel, ActivityModelType } from '../../db/Activity';
+import { ServerlistModel } from '../../db/Serverlist';
+import { reloadResources } from '../../pubUtils/data';
+import { getServerMainten, setServerMainten, stopServerMainten } from '../../services/gmService';
+import { taflush } from '../../services/sdkService';
+import { ActivityInRemote } from '../../domain/activityField/activityField';
+import { errlogger } from '../../util/logger';
+import { ActivityGroupModel } from '../../db/ActivityGroup';
+
+const activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
+const activities: Map<number, ActivityInRemote> = new Map(); // activityId => activity
+const activityByType: Map<number, Map<number, number[]>> = new Map(); // serverId => type => activityId[];
+const groupToServer: Map<number, number[]> = new Map(); // group => serverId[];
+
+export function clearData() {
+    activityByServer.clear();
+    activities.clear();
+    activityByType.clear();
+    groupToServer.clear();
+}
+
+export async function loadActivities() {
+    clearData();
+    let activityGroup = await ActivityGroupModel.findAllActivityGroup();
+    for(let { groupId, serverIds } of activityGroup) {
+        for(let serverId of serverIds) {
+            if(!groupToServer.has(groupId)) {
+                groupToServer.set(groupId, []);
+            }
+            groupToServer.get(groupId).push(serverId);
+        }
+    }
+
+    let activityDb = await ActivityModel.findOpenAndComingActivityes();
+    let activityIds: number[] = [];
+    for(let activity of activityDb) {
+        activities.set(activity.activityId, new ActivityInRemote(activity));
+        activityIds.push(activity.activityId);
+    }
+    setActivityTypeAndServer();
+
+    pinus.app.set('activityByServer', activityByServer);
+    pinus.app.set('activityByType', activityByType);
+    pinus.app.set('activities', activities);
+    pinus.app.set('groupToServer', groupToServer);
+}
+
+export async function setActivityTypeAndServer() {
+    
+    activityByServer.clear();
+    activityByType.clear();
+
+    for(let [_, activity] of activities) {
+        let servers = groupToServer.get(activity.groupId)||[];
+        for(let serverId of servers) {
+            if(!activityByServer.has(serverId)) {
+                activityByServer.set(serverId, []);
+            }
+            activityByServer.get(serverId).push(activity.activityId);
+
+            if(!activityByType.has(serverId)) {
+                activityByType.set(serverId, new Map());
+            }
+            if(!activityByType.get(serverId).has(activity.type)) {
+                activityByType.get(serverId).set(activity.type, []);
+            }
+            activityByType.get(serverId).get(activity.type).push(activity.activityId);
+        }
+    }
+
+    pinus.app.set('activityByServer', activityByServer);
+    pinus.app.set('activityByType', activityByType);
+    pinus.app.set('activities', activities);
+    pinus.app.set('groupToServer', groupToServer);
+}
+
+export function updateActivities(activityDb: ActivityInRemote[]) {
+    // console.log('******* activities', activities)
+    let activityIds: number[] = [];
+    for(let activity of activityDb) {
+        activities.set(activity.activityId, activity);
+        activityIds.push(activity.activityId);
+    }
+    setActivityTypeAndServer();
+}
+
+export function deleteActivities(activityIds: number[]) {
+
+    for(let activityId of activityIds) {
+        activities.delete(activityId);
+    }
+    setActivityTypeAndServer();
+}
+
+export function saveGroupToServer(groupId: number, serverIds: number[]) {
+
+    groupToServer.set(groupId, serverIds);
+    setActivityTypeAndServer();
+}
+
+export function saveActivitiesToGroup(groupId: number, activityDb: number[]) {
+    for(let activityId of activityDb) {
+        if(activities.get(activityId)) {
+            activities.get(activityId).groupId = groupId;
+        }
+    }
+    setActivityTypeAndServer();
+}
+
+export function _getActivityById(activityId: number) {
+    return <ActivityInRemote>activities?.get(activityId);
+}
+
+export function _getActivitiesByType(serverId: number, type: number) {
+    let activityByTypeData = activityByType?.get(serverId)?.get(type)??[];
+    let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
+    let result: ActivityInRemote[] = [];
+    for(let activityId of activityByTypeData) {
+        let activity = activities.get(activityId);
+        if(activity && activity.isEnable) {
+            result.push(activity);
+        }
+    }
+    return result;
+}
+
+export function _getActivitiesByServerId(serverId: number) {
+    let activityByServerId = activityByServer?.get(serverId)||[]
+    let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
+    let result: ActivityInRemote[] = [];
+    for(let activityId of activityByServerId) {
+        let activity = activities.get(activityId);
+        if(activity && activity.isEnable) {
+            result.push(activity);
+        }
+    }
+    return result;
+}
+
+export function _getActivities() {
+    try {
+        // console.log('***** activities', activities);
+        let result: ActivityInRemote[] = [];
+        for(let [_, activity] of activities) {
+            result.push(activity);
+        }
+        return result;
+    } catch(e) {
+        console.log('******** activity e', e)
+    }
+}
diff --git a/game-server/app/services/activity/activityService.ts b/game-server/app/services/activity/activityService.ts
index bd200624b..c712a01fc 100644
--- a/game-server/app/services/activity/activityService.ts
+++ b/game-server/app/services/activity/activityService.ts
@@ -10,7 +10,6 @@ import { getPlayerThirtyDaysData } from './thirtyDaysService';
 import { getPlayerVipRechargeMoneyData, } from './vipRechargeMoneyService';
 import { getPlayerActivityData, } from './selfServiceShopActivityService';
 import { ActivitySelfServiceGoodsModel } from '../../db/ActivitySelfServiceGoods';
-import moment = require('moment');
 import { getPlayerTreasureHuntDataShow } from './treasureHuntService';
 import { getPopUpShopDataShow } from './popUpShopService';
 import { getPlayerSevenDaysData } from './sevenDaysService';
@@ -32,7 +31,6 @@ import { getTimeLimitRankDataShow } from './timeLimitRankService';
 import { ActivityTaskPointModel } from '../../db/ActivityTaskPoint';
 import { getRoleOnlineInfo } from '../redisService';
 import { addTaskPassPoint, getTaskPassDataShow } from './taskPassService';
-import { getGuildChannelSid } from '../chatService';
 import { getGuildPayDataShow } from './guildPayService';
 import { PopUpShopItemShow } from '../../domain/activityField/popUpShopField';
 import { sendMessageToGuildWithSuc, sendMessageToUserWithSuc } from '../pushService';
@@ -40,6 +38,7 @@ import { UserOrderModelType } from '../../db/UserOrder';
 import { isArray } from 'underscore';
 import { getGuideGachaData } from './gachaService';
 import { getPopNoticeData } from './popNoticeService';
+import { _getActivities, _getActivitiesByServerId, _getActivitiesByType, _getActivityById } from './activityRemoteService';
 
 /**
    * 获取活动数据
@@ -293,51 +292,6 @@ export async function getActivityByServerId(serverId: number) {
     return activities.map(transActivityInRemoteToModelType);
 }
 
-export function _getActivityById(activityId: number) {
-    return <ActivityInRemote>pinus.app.get('activities')?.get(activityId);
-}
-
-export function _getActivitiesByType(serverId: number, type: number) {
-    let activityByType = pinus.app.get('activityByType')?.get(serverId)?.get(type)??[];
-    let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
-    let result: ActivityInRemote[] = [];
-    for(let activityId of activityByType) {
-        let activity = activities.get(activityId);
-        if(activity && activity.isEnable) {
-            result.push(activity);
-        }
-    }
-    return result;
-}
-
-export function _getActivitiesByServerId(serverId: number) {
-    let activityByServerId = pinus.app.get('activityByServer')?.get(serverId)||[]
-    let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
-    let result: ActivityInRemote[] = [];
-    for(let activityId of activityByServerId) {
-        let activity = activities.get(activityId);
-        if(activity && activity.isEnable) {
-            result.push(activity);
-        }
-    }
-    return result;
-}
-
-export function _getActivities() {
-    try {
-        let activities = pinus.app.get('activities');
-        // console.log('***** activities', activities);
-        let result: ActivityInRemote[] = [];
-        for(let [_, activity] of activities) {
-            result.push(activity);
-        }
-        return result;
-    } catch(e) {
-        console.log('******** activity e', e)
-    }
-}
-
-
 export async function checkActivityEditable(activities: ActivityModelType[]) {
     let now = new Date();
 
diff --git a/game-server/config/servers.ts b/game-server/config/servers.ts
index 66fc1f2d8..93b3fdd92 100644
--- a/game-server/config/servers.ts
+++ b/game-server/config/servers.ts
@@ -151,7 +151,6 @@ module.exports = {
             { 'id': 'guild-server-1', 'host': '172.26.145.161', 'port': 6057, "args": " --inspect=9239" },
         ],
         'activity': [
-            { 'id': 'activity-server-1', 'host': '172.26.145.161', 'port': 6059, "args": " --inspect=9241" },
         ],
         'order': [
             { 'id': 'order-server-1', 'host': '172.26.145.161', 'port': 6060, "args": " --inspect=9242" },
@@ -286,6 +285,9 @@ module.exports = {
         'guild': [
             { 'id': 'guild-server-3', 'host': '172.26.145.171', 'port': 6071 },
         ],
+        'activity': [
+            { 'id': 'activity-server-1', 'host': '172.26.145.171', 'port': 6059, "args": " --inspect=9241" },
+        ],
     },
     'sq1': {
         'connector': [