优化排行榜RankService，新增mongodb持久化Module

2026-02-04 06:54:45 +08:00 · 2022-11-23 09:45:26 +08:00
parent 5bea050f63
commit c7e0fcbdbb
7 changed files with 623 additions and 79 deletions
--- a/sysservice/rankservice/MongodbPersist.go
+++ b/sysservice/rankservice/MongodbPersist.go
@@ -0,0 +1,391 @@
+package rankservice
+
+import (
+	"fmt"
+	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/rpc"
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/sysmodule/mongodbmodule"
+	"github.com/duanhf2012/origin/util/coroutine"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+const batchRemoveNum  = 100
+const MaxDays = 180
+type RankDataDB struct {
+	Id                 uint64                      `bson:"_id,omitempty"`
+	RefreshTime        int64                       `bson:"RefreshTime,omitempty"`
+	SortData             []int64  				   `bson:"SortData,omitempty"`
+	Data                 []byte   				   `bson:"Data,omitempty"`
+}
+
+type MongoPersist struct {
+	service.Module
+	mongo mongodbmodule.MongoModule
+
+	url        string //连接url
+	dbName     string //数据库名称
+	SaveInterval time.Duration    //落地数据库时间间隔
+
+	waitGroup sync.WaitGroup
+	sync.Mutex
+	mapRemoveRankData map[uint64]map[uint64]struct{} //将要删除的排行数据 map[RankId]map[Key]struct{}
+	mapUpsertRankData map[uint64]map[uint64]RankData //需要upsert的排行数据 map[RankId][key]RankData
+	//mapRankCfg map[uint64]string 					 //map[RankId]RankCollectName
+
+	mapRankSkip map[uint64]IRankSkip
+	maxRetrySaveCount int  //存档重试次数
+	retryTimeIntervalMs time.Duration //重试时间间隔
+	stop int32
+}
+
+const CustomerCollectName = "SysCustomer"
+
+func (mp *MongoPersist) OnInit() error {
+	mp.mapRemoveRankData = map[uint64]map[uint64]struct{}{}
+	mp.mapUpsertRankData = map[uint64]map[uint64]RankData{}
+	//mp.mapRankCfg = map[uint64]string{}
+	mp.mapRankSkip = map[uint64]IRankSkip{}
+
+	if errC := mp.ReadCfg(); errC != nil {
+		return errC
+	}
+
+	err := mp.mongo.Init(mp.url, time.Second*15)
+	if err != nil {
+		return err
+	}
+
+	err = mp.mongo.Start()
+	if err != nil {
+		log.SError("start dbService[", mp.dbName, "], url[", mp.url, "] init error:", err.Error())
+		return err
+	}
+
+	coroutine.GoRecover(mp.persistCoroutine,-1)
+	return nil
+}
+
+func (mp *MongoPersist) ReadCfg() error {
+	mapDBServiceCfg, ok := mp.GetService().GetServiceCfg().(map[string]interface{})
+	if ok == false {
+		return fmt.Errorf("RankService config is error")
+	}
+
+
+	//读取数据库配置
+	saveMongoCfg,ok := mapDBServiceCfg["SaveMongo"]
+	if ok == false {
+		return fmt.Errorf("RankService.SaveMongo config is error")
+	}
+
+	mongodbCfg,ok := saveMongoCfg.(map[string]interface{})
+	if ok == false {
+		return fmt.Errorf("RankService.SaveMongo config is error")
+	}
+	
+	//parse MsgRouter
+	url, ok := mongodbCfg["Url"]
+	if ok == false {
+		return fmt.Errorf("RankService.SaveMongo.Url config  is error")
+	}
+	mp.url = url.(string)
+
+	dbName, ok := mongodbCfg["DBName"]
+	if ok == false {
+		return fmt.Errorf("RankService.SaveMongo.DBName config is error")
+	}
+	mp.dbName = dbName.(string)
+
+	saveInterval, ok := mongodbCfg["SaveIntervalMs"]
+	if ok == false {
+		return fmt.Errorf("RankService.SaveMongo.SaveIntervalMs config is error")
+	}
+
+	mp.SaveInterval = time.Duration(saveInterval.(float64))*time.Millisecond
+
+	maxRetrySaveCount, ok := mongodbCfg["MaxRetrySaveCount"]
+	if ok == false {
+		return fmt.Errorf("RankService.SaveMongo.MaxRetrySaveCount config is error")
+	}
+	mp.maxRetrySaveCount = int(maxRetrySaveCount.(float64))
+
+	retryTimeIntervalMs, ok := mongodbCfg["RetryTimeIntervalMs"]
+	if ok == false {
+		return fmt.Errorf("RankService.SaveMongo.RetryTimeIntervalMs config is error")
+	}
+	mp.retryTimeIntervalMs = time.Duration(retryTimeIntervalMs.(float64))*time.Millisecond
+
+
+	return nil
+}
+
+//启服从数据库加载
+func (mp *MongoPersist) OnStart() {
+}
+
+func (mp *MongoPersist)  OnFinishSetupRank(mapRankSkip map[uint64]*RankSkip) error{
+	mp.mapRankSkip = map[uint64]IRankSkip{}
+	for rankId,rank := range mapRankSkip {
+		mp.mapRankSkip[rankId] = rank
+	}
+
+	for rankId,rank := range mp.mapRankSkip{
+		err := mp.loadFromDB(rankId,rank.GetRankName())
+		if  err != nil {
+			log.SError("load from db is fail :%s",err.Error())
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (mp *MongoPersist) loadFromDB(rankId uint64,rankCollectName string) error{
+	s := mp.mongo.TakeSession()
+	ctx, cancel := s.GetDefaultContext()
+	defer cancel()
+
+	condition := bson.D{}
+	cursor, err := s.Collection(mp.dbName, rankCollectName).Find(ctx, condition)
+	if err != nil {
+		log.SError("find collect name ", rankCollectName, " is error:", err.Error())
+		return err
+	}
+
+	if cursor.Err()!=nil {
+		log.SError("find collect name ", rankCollectName, " is error:", cursor.Err().Error())
+		return err
+	}
+
+	rankSkip := mp.mapRankSkip[rankId]
+	if rankSkip == nil {
+		err = fmt.Errorf("rank ", rankCollectName, " is not setup:")
+		log.SError(err.Error())
+		return err
+	}
+
+	defer cursor.Close(ctx)
+	for cursor.Next(ctx) {
+		var rankDataDB RankDataDB
+		err = cursor.Decode(&rankDataDB)
+		if err != nil {
+			log.SError(" collect name ", rankCollectName, " Decode is error:", err.Error())
+			return err
+		}
+
+		var rankData rpc.RankData
+		rankData.Data = rankDataDB.Data
+		rankData.Key = rankDataDB.Id
+		rankData.SortData = rankDataDB.SortData
+
+		//更新到排行榜
+		rankSkip.UpsetRank(&rankData,rankDataDB.RefreshTime,true)
+	}
+
+	return nil
+}
+
+func (mp *MongoPersist) OnEnterRank(rankSkip IRankSkip, enterData *RankData){
+	mp.Lock()
+	defer mp.Unlock()
+
+	delete(mp.mapRemoveRankData,enterData.Key)
+
+	mp.lazyInitUpsertMap(rankSkip.GetRankID())
+	mp.mapUpsertRankData[rankSkip.GetRankID()][enterData.Key] = *enterData
+	//mp.SaveToDB()
+}
+
+func (mp *MongoPersist) lazyInitRemoveMap(rankId uint64){
+	if mp.mapRemoveRankData[rankId] == nil {
+		mp.mapRemoveRankData[rankId] = make(map[uint64]struct{},256)
+	}
+}
+
+func (mp *MongoPersist) lazyInitUpsertMap(rankId uint64){
+	if mp.mapUpsertRankData[rankId] == nil {
+		mp.mapUpsertRankData[rankId] = make(map[uint64]RankData,256)
+	}
+}
+
+func (mp *MongoPersist) OnLeaveRank(rankSkip IRankSkip, leaveData *RankData){
+	mp.Lock()
+	defer mp.Unlock()
+
+		//先删掉更新中的数据
+		delete(mp.mapUpsertRankData,leaveData.Key)
+		mp.lazyInitRemoveMap(rankSkip.GetRankID())
+		mp.mapRemoveRankData[rankSkip.GetRankID()][leaveData.Key] = struct{}{}
+}
+
+func (mp *MongoPersist) OnChangeRankData(rankSkip IRankSkip, changeData *RankData){
+	mp.Lock()
+	defer mp.Unlock()
+		//先删掉要删除的数据
+		delete(mp.mapRemoveRankData,changeData.Key)
+
+		//更新数据
+		mp.lazyInitUpsertMap(rankSkip.GetRankID())
+		mp.mapUpsertRankData[rankSkip.GetRankID()][changeData.Key] = *changeData
+}
+
+//停存持久化到DB
+func (mp *MongoPersist) OnStop(mapRankSkip map[uint64]*RankSkip){
+	atomic.StoreInt32(&mp.stop,1)
+	mp.waitGroup.Wait()
+}
+
+func (mp *MongoPersist)  persistCoroutine(){
+	mp.waitGroup.Add(1)
+	defer mp.waitGroup.Done()
+	for atomic.LoadInt32(&mp.stop)==0 || mp.hasPersistData(){
+		//间隔时间sleep
+		time.Sleep(mp.SaveInterval)
+
+		//没有持久化数据continue
+		if mp.hasPersistData() == false {
+			continue
+		}
+
+		//存档数据到数据库
+		mp.saveToDB()
+	}
+}
+
+func (mp *MongoPersist) hasPersistData() bool{
+	mp.Lock()
+	defer mp.Unlock()
+
+	return len(mp.mapUpsertRankData)>0 || len(mp.mapRemoveRankData) >0
+}
+
+func (mp *MongoPersist) saveToDB(){
+	//1.copy数据
+	mp.Lock()
+	mapRemoveRankData := mp.mapRemoveRankData
+	mapUpsertRankData := mp.mapUpsertRankData
+	mp.mapRemoveRankData = map[uint64]map[uint64]struct{}{}
+	mp.mapUpsertRankData = map[uint64]map[uint64]RankData{}
+	mp.Unlock()
+
+	//2.存档
+	for len(mapUpsertRankData) > 0 {
+		mp.upsertRankDataToDB(mapUpsertRankData)
+	}
+
+	for len(mapRemoveRankData) >0 {
+		mp.removeRankDataToDB(mapRemoveRankData)
+	}
+}
+
+func (mp *MongoPersist) removeToDB(collectName string,keys []uint64) error{
+	s := mp.mongo.TakeSession()
+	ctx, cancel := s.GetDefaultContext()
+	defer cancel()
+
+	condition := bson.D{{Key: "_id", Value: bson.M{"$in": keys}}}
+	_, err := s.Collection(mp.dbName, collectName).DeleteMany(ctx, condition)
+	if err != nil {
+		log.SError("MongoPersist DeleteMany fail,collect name is ", collectName)
+		return err
+	}
+
+	return nil
+}
+
+func (mp *MongoPersist) removeRankData(rankId uint64,keys []uint64) bool {
+	rank := mp.mapRankSkip[rankId]
+	if rank== nil {
+		log.SError("cannot find rankId ",rankId,"config")
+		return false
+	}
+
+	for i:=0;i<mp.maxRetrySaveCount;i++{
+		//不成功则一直重试
+		if mp.removeToDB(rank.GetRankName(),keys)!= nil {
+			time.Sleep(mp.retryTimeIntervalMs)
+			continue
+		}
+		break
+	}
+
+	return true
+}
+
+func (mp *MongoPersist) upsertToDB(collectName string,rankData *RankData) error{
+	condition := bson.D{{"_id", rankData.Key}}
+	upsert := bson.M{"_id":rankData.Key,"RefreshTime": rankData.refreshTimestamp, "SortData": rankData.SortData, "Data": rankData.Data}
+	update := bson.M{"$set": upsert}
+
+	s := mp.mongo.TakeSession()
+	ctx, cancel := s.GetDefaultContext()
+	defer cancel()
+
+	updateOpts := options.Update().SetUpsert(true)
+	_, err := s.Collection(mp.dbName, collectName).UpdateOne(ctx, condition,update,updateOpts)
+	if err != nil {
+		log.SError("MongoPersist upsertDB fail,collect name is ", collectName)
+		return err
+	}
+
+	return nil
+}
+
+func (mp *MongoPersist) upsertRankDataToDB(mapUpsertRankData map[uint64]map[uint64]RankData) error{
+	for rankId,mapRankData := range  mapUpsertRankData{
+		rank,ok := mp.mapRankSkip[rankId]
+		if ok == false {
+			log.SError("cannot find rankId ",rankId,",config is error")
+			delete(mapUpsertRankData,rankId)
+			continue
+		}
+
+		for key,rankData := range mapRankData{
+			//最大重试mp.maxRetrySaveCount次
+			for i:=0;i<mp.maxRetrySaveCount;i++{
+				err := mp.upsertToDB(rank.GetRankName(),&rankData)
+				if err != nil {
+					time.Sleep(mp.retryTimeIntervalMs)
+					continue
+				}
+				break
+			}
+
+			//存完删掉指定key
+			delete(mapRankData,key)
+		}
+
+		if len(mapRankData) == 0 {
+			delete(mapUpsertRankData,rankId)
+		}
+	}
+
+	return nil
+}
+
+func (mp *MongoPersist) removeRankDataToDB(mapRemoveRankData map[uint64]map[uint64]struct{}) {
+	for rankId ,mapRemoveKey := range  mapRemoveRankData{
+		//每100个一删
+		keyList := make([]uint64,0,batchRemoveNum)
+		 for key := range mapRemoveKey {
+			 delete(mapRemoveKey,key)
+			 keyList = append(keyList,key)
+			 if len(keyList) >= batchRemoveNum {
+				 break
+			 }
+		 }
+
+		mp.removeRankData(rankId,keyList)
+
+		 //如果删完，删掉rankid下所有
+		 if len(mapRemoveKey) == 0 {
+			 delete(mapRemoveRankData,rankId)
+		 }
+	}
+
+}
--- a/sysservice/rankservice/RankData.go
+++ b/sysservice/rankservice/RankData.go
@@ -15,18 +15,20 @@ var RankDataPool = sync.NewPoolEx(make(chan sync.IPoolData, 10240), func() sync.

 type RankData struct {
 	*rpc.RankData
-	bRelease bool
+	refreshTimestamp int64 //刷新时间
+	//bRelease bool
 	ref         bool
 	compareFunc func(other skip.Comparator) int
 }

-func NewRankData(isDec bool, data *rpc.RankData) *RankData {
+func NewRankData(isDec bool, data *rpc.RankData,refreshTimestamp int64) *RankData {
 	ret := RankDataPool.Get().(*RankData)
 	ret.compareFunc = ret.ascCompare
 	if isDec {
 		ret.compareFunc = ret.desCompare
 	}
 	ret.RankData = data
+	ret.refreshTimestamp = refreshTimestamp

 	return ret
 }
--- a/sysservice/rankservice/RankDataExpire.go
+++ b/sysservice/rankservice/RankDataExpire.go
@@ -93,7 +93,7 @@ func (rd *rankDataHeap) PopExpireKey() uint64{
 	return  rankData.Key
 }

-func (rd *rankDataHeap) PushOrRefreshExpireKey(key uint64){
+func (rd *rankDataHeap) PushOrRefreshExpireKey(key uint64,refreshTimestamp int64){
 	//1.先删掉之前的
 	expData ,ok := rd.mapExpireData[key]
 	if ok == true {
@@ -105,7 +105,7 @@ func (rd *rankDataHeap) PushOrRefreshExpireKey(key uint64){
 	//2.直接插入
 	expData = expireDataPool.Get().(*ExpireData)
 	expData.Key = key
-	expData.RefreshTimestamp = time.Now().UnixNano()
+	expData.RefreshTimestamp = refreshTimestamp
 	rd.mapExpireData[key] = expData

 	heap.Push(rd,expData)
--- a/sysservice/rankservice/RankInterface.go
+++ b/sysservice/rankservice/RankInterface.go
@@ -1,6 +1,9 @@
 package rankservice

-import "github.com/duanhf2012/origin/service"
+import (
+	"github.com/duanhf2012/origin/service"
+	"github.com/duanhf2012/origin/rpc"
+)

 type RankDataChangeType int8

@@ -8,16 +11,21 @@ type RankDataChangeType int8

 type IRankSkip interface {
 	GetRankID() uint64
+	GetRankName() string
 	GetRankLen() uint64
+	UpsetRank(upsetData *rpc.RankData,refreshTimestamp int64,fromLoad bool) (*RankData, RankDataChangeType)
 }

+
+
 type IRankModule interface {
 	service.IModule

-	OnStart(mapRankSkip map[uint64]*RankSkip) error              //服务开启时回调
-	OnEnterRank(rankSkip IRankSkip, enterData []*RankData)       //进入排行
-	OnLeaveRank(rankSkip IRankSkip, leaveData []*RankData)       //离开排行
-	OnChangeRankData(rankSkip IRankSkip, changeData []*RankData) //当排行数据变化时
+	OnFinishSetupRank(map[uint64]*RankSkip) error 			//当完成安装排行榜对象时
+	OnStart()               //服务开启时回调
+	OnEnterRank(rankSkip IRankSkip, enterData *RankData)       //进入排行
+	OnLeaveRank(rankSkip IRankSkip, leaveData *RankData)       //离开排行
+	OnChangeRankData(rankSkip IRankSkip, changeData *RankData) //当排行数据变化时
 	OnStop(mapRankSkip map[uint64]*RankSkip)                     //服务结束时回调
 }

--- a/sysservice/rankservice/RankService.go
+++ b/sysservice/rankservice/RankService.go
@@ -18,14 +18,8 @@ type RankService struct {
 }

 func (rs *RankService) OnInit() error {
-	rs.mapRankSkip = make(map[uint64]*RankSkip, PreMapRankSkipLen)
-	err := rs.dealCfg()
-	if err != nil {
-		return err
-	}
-
 	if rs.rankModule != nil {
-		_, err = rs.AddModule(rs.rankModule)
+		_, err := rs.AddModule(rs.rankModule)
 		if err != nil {
 			return err
 		}
@@ -33,11 +27,19 @@ func (rs *RankService) OnInit() error {
 		rs.AddModule(&DefaultRankModule{})
 	}

+	rs.mapRankSkip = make(map[uint64]*RankSkip, PreMapRankSkipLen)
+	err := rs.dealCfg()
+	if err != nil {
+		return err
+	}
+
+
+
 	return nil
 }

 func (rs *RankService) OnStart() {
-	rs.rankModule.OnStart(rs.mapRankSkip)
+	rs.rankModule.OnStart()
 }

 func (rs *RankService) OnRelease() {
@@ -58,7 +60,8 @@ func (rs *RankService) RPC_ManualAddRankSkip(addInfo *rpc.AddRankList, addResult
 			return fmt.Errorf("RPC_AddRankSkip must has rank id")
 		}

-		newSkip := NewRankSkip(addRankListData.IsDec, transformLevel(addRankListData.SkipListLevel), addRankListData.MaxRank,time.Duration(addRankListData.ExpireMs)*time.Millisecond)
+		newSkip := NewRankSkip(addRankListData.RankId,"",addRankListData.IsDec, transformLevel(addRankListData.SkipListLevel), addRankListData.MaxRank,time.Duration(addRankListData.ExpireMs)*time.Millisecond)
+		newSkip.SetupRankModule(rs.rankModule)
 		rs.mapRankSkip[addRankListData.RankId] = newSkip
 		addList = append(addList, addRankListData.RankId)
 	}
@@ -75,7 +78,7 @@ func (rs *RankService) RPC_UpsetRank(upsetInfo *rpc.UpsetRankData, upsetResult *
 		return fmt.Errorf("RPC_UpsetRank[", upsetInfo.RankId, "] no this rank id")
 	}

-	addCount, updateCount := rankSkip.UpsetRank(upsetInfo.RankDataList)
+	addCount, updateCount := rankSkip.UpsetRankList(upsetInfo.RankDataList)
 	upsetResult.AddCount = addCount
 	upsetResult.ModifyCount = updateCount
 	return nil
@@ -135,11 +138,30 @@ func (rs *RankService) RPC_FindRankDataByRank(findInfo *rpc.FindRankDataByRank,
 func (rs *RankService) RPC_FindRankDataList(findInfo *rpc.FindRankDataList, findResult *rpc.RankDataList) error {
 	rankObj, ok := rs.mapRankSkip[findInfo.RankId]
 	if ok == false || rankObj == nil {
-		return fmt.Errorf("RPC_FindRankDataListStartTo[", findInfo.RankId, "] no this rank type")
+		err := fmt.Errorf("not config rank %d",findInfo.RankId)
+		log.SError(err.Error())
+		return err
 	}

 	findResult.RankDataCount = rankObj.GetRankLen()
-	return rankObj.GetRankDataFromToLimit(findInfo.StartRank, findInfo.Count, findResult)
+	err := rankObj.GetRankDataFromToLimit(findInfo.StartRank-1, findInfo.Count, findResult)
+	if err != nil {
+		return err
+	}
+
+	//查询附带的key
+	if findInfo.Key!= 0 {
+		findRankData, rank := rankObj.GetRankNodeData(findInfo.Key)
+		if findRankData != nil {
+			findResult.KeyRank = &rpc.RankPosData{}
+			findResult.KeyRank.Data = findRankData.Data
+			findResult.KeyRank.Key = findRankData.Key
+			findResult.KeyRank.SortData = findRankData.SortData
+			findResult.KeyRank.Rank = rank
+		}
+	}
+
+	return nil
 }

 func (rs *RankService) deleteRankList(delIdList []uint64) {
@@ -170,21 +192,27 @@ func (rs *RankService) dealCfg() error {
 		}

 		rankId, okId := mapCfg["RankID"].(float64)
-		if okId == false {
+		if okId == false || uint64(rankId)==0 {
 			return fmt.Errorf("RankService SortCfg data must has RankID[number]")
 		}

+		rankName, okId := mapCfg["RankName"].(string)
+		if okId == false || len(rankName)==0 {
+			return fmt.Errorf("RankService SortCfg data must has RankName[string]")
+		}
+
 		level, _ := mapCfg["SkipListLevel"].(float64)
 		isDec, _ := mapCfg["IsDec"].(bool)
 		maxRank, _ := mapCfg["MaxRank"].(float64)
 		expireMs, _ := mapCfg["ExpireMs"].(float64)

-		newSkip := NewRankSkip(isDec, transformLevel(int32(level)), uint64(maxRank),time.Duration(expireMs)*time.Millisecond)
+
+		newSkip := NewRankSkip(uint64(rankId),rankName,isDec, transformLevel(int32(level)), uint64(maxRank),time.Duration(expireMs)*time.Millisecond)
+		newSkip.SetupRankModule(rs.rankModule)
 		rs.mapRankSkip[uint64(rankId)] = newSkip
 	}

-
-	return nil
+	return rs.rankModule.OnFinishSetupRank(rs.mapRankSkip)
 }


--- a/sysservice/rankservice/RankSkip.go
+++ b/sysservice/rankservice/RankSkip.go
@@ -9,6 +9,7 @@ import (

 type RankSkip struct {
 	rankId      uint64               //排行榜ID
+	rankName    string               //排行榜名称
 	isDes       bool                 //是否为降序 true：降序 false：升序
 	skipList    *skip.SkipList       //跳表
 	mapRankData map[uint64]*RankData //排行数据map
@@ -27,9 +28,11 @@ const (
 )

 // NewRankSkip 创建排行榜
-func NewRankSkip(isDes bool, level interface{}, maxLen uint64,expireMs time.Duration) *RankSkip {
+func NewRankSkip(rankId uint64,rankName string,isDes bool, level interface{}, maxLen uint64,expireMs time.Duration) *RankSkip {
 	rs := &RankSkip{}

+	rs.rankId = rankId
+	rs.rankName = rankName
 	rs.isDes = isDes
 	rs.skipList = skip.New(level)
 	rs.mapRankData = make(map[uint64]*RankData, 10240)
@@ -64,16 +67,21 @@ func (rs *RankSkip) GetRankID() uint64 {
 	return rs.rankId
 }

+// GetRankName 获取排行榜名称
+func (rs *RankSkip) GetRankName() string {
+	return rs.rankName
+}
+
 // GetRankLen 获取排行榜长度
 func (rs *RankSkip) GetRankLen() uint64 {
 	return rs.skipList.Len()
 }

-func (rs *RankSkip) UpsetRank(upsetRankData []*rpc.RankData) (addCount int32, modifyCount int32) {
+func (rs *RankSkip) UpsetRankList(upsetRankData []*rpc.RankData) (addCount int32, modifyCount int32) {
 	addList := make([]*RankData, 0, 1)
 	updateList := make([]*RankData, 0, 1)
 	for _, upsetData := range upsetRankData {
-		changeData, changeType := rs.upsetRank(upsetData)
+		changeData, changeType := rs.UpsetRank(upsetData,time.Now().UnixNano(),false)
 		if changeData == nil {
 			continue
 		}
@@ -86,6 +94,7 @@ func (rs *RankSkip) UpsetRank(upsetRankData []*rpc.RankData) (addCount int32, mo
 		}
 	}

+	/*
 	if len(addList) > 0 {
 		rs.rankModule.OnEnterRank(rs, addList)
 	}
@@ -93,7 +102,7 @@ func (rs *RankSkip) UpsetRank(upsetRankData []*rpc.RankData) (addCount int32, mo
 	if len(updateList) > 0 {
 		rs.rankModule.OnChangeRankData(rs, updateList)
 	}
-
+*/
 	addCount = int32(len(addList))
 	modifyCount = int32(len(updateList))

@@ -102,12 +111,17 @@ func (rs *RankSkip) UpsetRank(upsetRankData []*rpc.RankData) (addCount int32, mo
 }

 // UpsetRank 更新玩家排行数据,返回变化后的数据及变化类型
-func (rs *RankSkip) upsetRank(upsetData *rpc.RankData) (*RankData, RankDataChangeType) {
+func (rs *RankSkip) UpsetRank(upsetData *rpc.RankData,refreshTimestamp int64,fromLoad bool) (*RankData, RankDataChangeType) {
 	rankNode, ok := rs.mapRankData[upsetData.Key]
 	if ok == true {
 		//找到的情况对比排名数据是否有变化,无变化进行data更新,有变化则进行删除更新
 		if compareIsEqual(rankNode.SortData, upsetData.SortData) {
 			rankNode.Data = upsetData.GetData()
+			rankNode.refreshTimestamp = refreshTimestamp
+
+			if fromLoad == false {
+				rs.rankModule.OnChangeRankData(rs,rankNode)
+			}
 			return nil, RankDataNone
 		}

@@ -117,21 +131,29 @@ func (rs *RankSkip) upsetRank(upsetData *rpc.RankData) (*RankData, RankDataChang
 		rs.skipList.Delete(rankNode)
 		ReleaseRankData(rankNode)

-		newRankData := NewRankData(rs.isDes, upsetData)
+		newRankData := NewRankData(rs.isDes, upsetData,refreshTimestamp)
 		rs.skipList.Insert(newRankData)
 		rs.mapRankData[upsetData.Key] = newRankData

 		//刷新有效期
-		rs.rankDataExpire.PushOrRefreshExpireKey(upsetData.Key)
+		rs.rankDataExpire.PushOrRefreshExpireKey(upsetData.Key,refreshTimestamp)

+		if fromLoad == false {
+			rs.rankModule.OnChangeRankData(rs, rankNode)
+		}
 		return newRankData, RankDataUpdate
 	}

 	if rs.checkInsertAndReplace(upsetData) {
-		newRankData := NewRankData(rs.isDes, upsetData)
+		newRankData := NewRankData(rs.isDes, upsetData,refreshTimestamp)
 		rs.skipList.Insert(newRankData)
 		rs.mapRankData[upsetData.Key] = newRankData
-		rs.rankDataExpire.PushOrRefreshExpireKey(upsetData.Key)
+		rs.rankDataExpire.PushOrRefreshExpireKey(upsetData.Key,refreshTimestamp)
+
+		if fromLoad == false {
+			rs.rankModule.OnEnterRank(rs, newRankData)
+		}
+
 		return newRankData, RankDataAdd
 	}

@@ -140,7 +162,7 @@ func (rs *RankSkip) upsetRank(upsetData *rpc.RankData) (*RankData, RankDataChang

 // DeleteRankData 删除排行数据
 func (rs *RankSkip) DeleteRankData(delKeys []uint64) int32 {
-	removeRankData := make([]*RankData, 0, 1)
+	var removeRankData int32
 	//预统计处理，进行回调
 	for _, key := range delKeys {
 		rankData, ok := rs.mapRankData[key]
@@ -148,20 +170,16 @@ func (rs *RankSkip) DeleteRankData(delKeys []uint64) int32 {
 			continue
 		}

-		removeRankData = append(removeRankData, rankData)
-	}
-	rs.rankModule.OnLeaveRank(rs, removeRankData)
-
-	//从排行榜中删除
-	for _, rankData := range removeRankData {
+		removeRankData+=1
 		rs.skipList.Delete(rankData)
 		delete(rs.mapRankData, rankData.Key)
 		rs.rankDataExpire.RemoveExpireKey(rankData.Key)
+		rs.rankModule.OnLeaveRank(rs, rankData)
 		ReleaseRankData(rankData)
 	}

 	rs.pickExpireKey()
-	return int32(len(removeRankData))
+	return removeRankData
 }

 // GetRankNodeData 获取,返回排名节点与名次
@@ -172,12 +190,12 @@ func (rs *RankSkip) GetRankNodeData(findKey uint64) (*RankData, uint64) {
 	}

 	_, index := rs.skipList.GetWithPosition(rankNode)
-	return rankNode, index
+	return rankNode, index+1
 }

 // GetRankNodeDataByPos 获取,返回排名节点与名次
 func (rs *RankSkip) GetRankNodeDataByRank(rank uint64) (*RankData, uint64) {
-	rankNode := rs.skipList.ByPosition(rank)
+	rankNode := rs.skipList.ByPosition(rank-1)
 	if rankNode == nil {
 		return nil, 0
 	}
@@ -203,7 +221,7 @@ func (rs *RankSkip) GetRankKeyPrevToLimit(findKey, count uint64, result *rpc.Ran
 		rankData := iter.Value().(*RankData)
 		result.RankPosDataList = append(result.RankPosDataList, &rpc.RankPosData{
 			Key:      rankData.Key,
-			Rank:  rankPos - iterCount,
+			Rank:  rankPos - iterCount+1,
 			SortData: rankData.SortData,
 			Data:     rankData.Data,
 		})
@@ -231,7 +249,7 @@ func (rs *RankSkip) GetRankKeyNextToLimit(findKey, count uint64, result *rpc.Ran
 		rankData := iter.Value().(*RankData)
 		result.RankPosDataList = append(result.RankPosDataList, &rpc.RankPosData{
 			Key:      rankData.Key,
-			Rank:  rankPos + iterCount,
+			Rank:  rankPos + iterCount+1,
 			SortData: rankData.SortData,
 			Data:     rankData.Data,
 		})
@@ -244,7 +262,8 @@ func (rs *RankSkip) GetRankKeyNextToLimit(findKey, count uint64, result *rpc.Ran
 // GetRankList 获取排行榜数据,startPos开始的count个数据
 func (rs *RankSkip) GetRankDataFromToLimit(startPos, count uint64, result *rpc.RankDataList) error {
 	if rs.GetRankLen() <= 0 {
-		return fmt.Errorf("rank[", rs.rankId, "] no data")
+		//初始排行榜可能没有数据
+		return nil
 	}

 	if result.RankDataCount < startPos {
@@ -257,7 +276,7 @@ func (rs *RankSkip) GetRankDataFromToLimit(startPos, count uint64, result *rpc.R
 		rankData := iter.Value().(*RankData)
 		result.RankPosDataList = append(result.RankPosDataList, &rpc.RankPosData{
 			Key:      rankData.Key,
-			Rank:  iterCount + startPos,
+			Rank:  iterCount + startPos+1,
 			SortData: rankData.SortData,
 			Data:     rankData.Data,
 		})
@@ -292,7 +311,7 @@ func (rs *RankSkip) checkInsertAndReplace(upsetData *rpc.RankData) bool {
 	//移除最后一位
 	//回调模块，该RandData从排行中删除
 	rs.rankDataExpire.RemoveExpireKey(lastRankData.Key)
-	rs.rankModule.OnLeaveRank(rs, []*RankData{lastRankData})
+	rs.rankModule.OnLeaveRank(rs, lastRankData)
 	rs.skipList.Delete(lastPosData)
 	delete(rs.mapRankData, lastRankData.Key)
 	ReleaseRankData(lastRankData)