国产精品久久久亚洲,久久91精品国产91,国产成人久久AV免费

自動刪除的定時器隊列

自動刪除的定時器隊列

（金慶的專欄）

網游服務器中使用定時器隊列代替角色遍歷可以提高性能，同時簡代邏輯。
游戲主循環中不必遍歷角色，只需觸發定時器動作。

主循環代碼如：

RootTimerQueue & rTimerQueue = Singleton<RootTimerQueue>();
do
{
   UpdateTimeNow(); // update m_rNow
   bool bTimerActed = rTimerQueue.TryToTickOne(m_rNow);
   size_t nCount = HandleMessages();

   if (0 == nCount)
   {
       if (m_bStopped) break;
       if (bTimerActed) continue;
       boost::this_thread::sleep(boost::posix_time::milliseconds(1));
   }
} while (true);

定時器運行與主循環線程。
RootTimerQueue為根隊列，單件，各功能的定時器為RootTimerQueue的子隊列。

定時器隊列需要一個自動刪除功能。
如角色相關的一大堆定時器動作需要在角色退出時自動刪除。
不然定時器動作在角色不存在時或重新登錄后觸發，會造成錯誤。
如果采用角色臨時ID（會話ID）, 每次登錄都不相同，
可以避免錯誤，定時器動作就成為一個空動作。
但是該動作一直存在于隊列中會占用內存，無法清除。

解決方案是每個角色擁有一個自己的定時器隊列，該隊列為根隊列的子隊列。
角色退出時，子隊列的刪除會自動刪除所有的定時器動作。

class TimerQueue : boost::noncopyable
{
public:
   typedef boost::function<void ()> Action;
   typedef UInt64 TimerId;

public:
    TimerId Insert(time_t tStart, const Action & act, unsigned int nIntervalSec = 0);
   void Erase(TiemrId id);

public:
    void SetParent(TimerQueue * p);

public:
    bool TryToTickOne(time_t tNow);
};

時間精度為秒，因為現在的應用只需秒即可，可以稍加改動替換成高精度時間。

定時器動作分為2類：
1. 只做一次，nIntervalSec為0表示只做一次。
2. 重復做，nIntervalSec非0.

添加定時器只有一個開始時間（有需要可以加個結束時間）。
開始時間可以是登錄前的一個時間點，這樣就可以計算離線期間所發生的改變。

通過SetParent()將自己設為某個隊列的子隊列。

實現部分如下：

class TimerQueue : boost::nonecopyable
{
private:
   void TickOne();
   void SetNextTime();
   void EraseParentTimer();

private:
   typedef UInt64 TimerSeq;

private:
   struct TimerItem
   {
       time_t t;
       TimerSeq seq;
       Action act;
       unsigned int nIntervalSec;
   };

private:
   void InsertItem(const TimerItem & itm);
   TimerItem Pop();

private:
    struct TimerOrder {};

   typedef boost::multi_index::multi_index_container
   <
       TimerItem,

       boost::multi_index::indexed_by
       <
           boost::multi_index::ordered_unique<
               boost::multi_index::tag<TimerOrder>,
               boost::multi_index::composite_key<
                   TimerItem,
                   boost::multi_index::member<TimerItem, time_t, &TimerItem::t>,
                   boost::multi_index::member<IimerItem, TimerSeq, &TimerItem::seq>
               > // composite_key
           >, // ordered_unique
           boost::multi_index::hashed_unique<
               boost::multi_index::tag<TimerId>,
               boost::multi_index::member<TimerItem, TimerSeq, &TimerItem::seq>
           > // hashed_unique
       > // indexed_by
   > TimerItemSet;

   typedef TimerItemSet::index<TimerOrder>::type QueueByTime;
   typedef TimerItemSet::index<TimerId>::type QueueById;

private:
    TimerItemSet m_set;

private:
    TimerSeq m_seq;
   time_t m_tNext;

   TimerQueue * m_pParent;
   TimerId m_idParentTimer; // Used to erase timer from parent
};

TimerItemSet以時間和序號排序，允許時間相同，但序號是唯一的。
并且也能用ID號索引，用于刪除定時器。

TimerQueue.cpp

TimerQueue::TimerQueue()
   : m_seq(0) // 0 is illegal
   , m_pParent(NULL)
   , m_idParentTimer(0)
{
   SetNextTime();
}

TimerQueue::~TimerQueue()
{
   EraseParentTimer();
}

TimerQueue::TimerId TimerQueue::Insert(
   time_t tStart, const Action & act, unsigned int nIntervalSec)
{
   TimerItem itm = {tStart, ++m_seq, act, nIntervalSec};
   InsertItem(itm);
   return itm.seq;
}

TimerQueue::Erase(TimerId id)
{
   SetById & rSet = mset.get<TimerId>();
   SetById::iterator itr = rSet.find(id);
   if (itr == rSet.end())
       return;

   time_t t = (*itr).t;
   TimerSeq seqErase = (*itr).seq; // Used to set next time.
   TimerSeq seqFront = m_set.get<TimerOrder>().begin()->seq;
   rSet.erase(itr);
   if (seqErase == seqFront)
       SetNextTime();
}

void TimerQueue::SetParent(TimerQueue * p)
{
   EraseParentTimer()
   m_pParent = p
   SetNextTime();
}

bool TimerQueue::TryToTickOne(time_t tNow)
{
   if (tNow < m_tNext)
       return false;
   if (m_set.empty())
       return false;

   TickOne();
   return true;
}

void TimerQueue::TickOne()
{
   BOOST_ASSERT(!m_set.empty());
   TimerItem itm = Pop();
   itm.act();

   if (0 == itm.nIntervalSec)
       return;
   itm.t += itm.nIntervalSec;
   InsertItem(itm);
}

TimerQueue::TimerItem TimerQueue::Pop()
{
   BOOST_ASSERT(!m_set.empty());
   QueueByTime & rQ = m_set.get<TimerOrder>();
   QueueByTime::iterator itr = rQ.begin();
   TimerItem itm = *itr;
   rQ.erase(itr);
   BOOST_ASSERT(itm.t == m_tNext);
   SetNextTime();
   return itm;
}

void TimerQueue::SetNextTime()
{
   EraseParentTimer();

   if (m_set.empty())
   {
       m_tNext = std::numeric_limits<time_t>::max();
       return;
   }
   time_t tNew = (*m_set.get<TimeOrder>().begin()).t;
   m_tNext = tNew;
   if (NULL == m_pParent)
        return;
   m_idParentTimer = m_pParent->Insert(m_tNext,
       boost::bind(&TimerQueue::TickOne, this));
   BOOST_ASSERT(m_idParentTimer); // 0 is illegal ID.
}

void TimerQueue::EraseParentTimer()
{
   if (m_pParent && m_idParentTimer)
       m_pParent->Erase(m_idParentTimer);
   m_idParentTimer = 0;
}

void TimerQueue::InsertItem(const TimerIten & itm)
{
   m_set.insert(itm);
   if (itm.t < m_tNext)
       SetNextTiem();
}

RootTimerQueue是TimerQueue的子類。
另外再派生子類
class LogicTimerQueue : public TimerQueue
{
public:
   LogicTimerQueue();
};

LogicTimerQueue::LogicTimerQueue()
{
   SetParent(&Singleton<RootTimerQueue>());
}

這樣就讓每個LogicTimerQueue成為根隊列的子隊列。

玩家類中就可以添加LogicTimerQueue成員，來執行定時動作。

class Player
{
public:
   Player()
   {
       ...
        // Check mail every hour.
       m_timer->Insert(time(NULL),
           boost::bind(&Player::CheckMail, this),
           3600);
       ...
   }

...

private:
   LogicTimerQueue m_timer;
   ...
};

posted on 2012-06-20 13:28 金慶閱讀(1140) 評論(2) 編輯收藏引用所屬分類: 1. C/C++ 、2. 網游開發

只有注冊用戶登錄后才能發表評論。
【推薦】100%開源！大型工業跨平臺軟件C++源碼提供，建模，組態！

相關文章: How are dtLinks created in NavMesh C++ parameter passing rules Naming Conventions for Accessors Visual Studio 2019 Compiler Hangs Fbx File Format Identifier 查找內存錯誤 std::thread 中的異常會丟失調用棧用賦值代替 protobuf CopyFrom() vs2017 linux 編譯輸出改成 vs 格式為 LiteIDE 添加選中標記

網站導航: 博客園 IT新聞 BlogJava 博問 Chat2DB 管理

金慶的專欄

公告

留言簿(12)

隨筆分類(502)

隨筆檔案(423)

相冊

搜索

積分與排名

最新評論

閱讀排行榜

評論排行榜

評論