libjingle开发系列之三：消息机制
我承认我懒，本来是想写的，发现已经有人写了，那算了。转帖一篇吧：
一. Thread类是libjingle中比较核心的类。 我把他的功能主要分为三块：
1. Thread相关函数: 主要是对不同操作系统Thread的统一接口包装。 其中包括了Start(), Stop(), Join()等线程控制函数， 也包括了优先级控制相关的函数， 还有一个定位查找的功能。关于定位查找的功能主要是由ThreadManager控制的， ThreadManager类主要是对Thread进行管理。当然会有一个global的ThreadManager的对象来进行所有Thread对象的注册，定位，查找等操作。 Thread中的执行函数是PreRun()。 在PreRun()函数中就是用ThreadManager：：SetCurrent()函数来设置当前的Thread。
2. 消息机制: 这个功能主要是由继承MessageQueue中的来获取的。
Thread中的核心函数就是ProcessMessages():
bool Thread::ProcessMessages(int cmsLoop) {
uint32 msEnd;
if (cmsLoop != kForever)
msEnd = GetMillisecondCount() + cmsLoop;
int cmsNext = cmsLoop;
while (true) {
Message msg;
if (!Get(&msg, cmsNext))
return false;
Dispatch(&msg);
if (cmsLoop != kForever) {
uint32 msCur = GetMillisecondCount();
if (msCur >= msEnd)
return true;
cmsNext = msEnd - msCur;
}
}
}
此函数主要是循环地得到消息，分派消息。当然这边有超时的机制。这边主要用到了MessageQueue：：Get()和Dispatch()函数，
这个等下会着重介绍。
3. 进行异步网络事件监听的功能。主要是继承了SocketServer而获得的功能。 (这里要注意是因为MessageQueue继承SocketServer的原因，PS: 这边我个人觉得应该分开这两块功能接口更舒服。) 这个等下也会着重介绍。
二. MessageQueue: (这段懂得消息机制的朋友可以略过...)
MessageQueue主要是实现了一个消息队列来Post, Get, Peek消息。 主要用处么，将处理逻辑和内容解耦，在编程中经常用的手法。
1. 消息格式:
struct Message {
Message() {
memset(this, 0, sizeof(*this)); // 初始化
}
MessageHandler *phandler; // Message的回调函数，用来处理得到消息的操作。
uint32 message_id; // message id
MessageData *pdata; // message data是个标志接口
uint32 ts_sensitive; // ？
};
2. 消息队列类型:
这里主要有两种消息队列类型，一种是一般的先进先出的消息队列，还有一种是可以设置delayed时间根据delayed时间排列的优先级队列。
2. 发消息:
我们使用Post函数来发消息。
void MessageQueue::Post(MessageHandler *phandler, uint32 id,
MessageData *pdata, bool time_sensitive) {
if (fStop_)
return;
// Keep thread safe
// Add the message to the end of the queue
// Signal for the multiplexer to return
CritScope cs(&crit_);
EnsureActive();
Message msg;
msg.phandler = phandler;
msg.message_id = id;
msg.pdata = pdata;
if (time_sensitive) {
msg.ts_sensitive = Time() + kMaxMsgLatency;
}
msgq_.push(msg);
ss_->WakeUp();
}
这里主要就组成了一个Message，然后放到消息队列尾部了，此操作是线程安全的。 此外，还调用了socketserver多路复用器的WakeUp()方法来唤醒正在一定时间内循坏等待的多路复用器。
同样PostDelayed就是发消息到一个优先级队列中去。
3. 取消息:
我们使用Get（）来获得消息。
bool MessageQueue::Get(Message *pmsg, int cmsWait) {
// Return and clear peek if present
// Always return the peek if it exists so there is Peek/Get symmetry
if (fPeekKeep_) {
*pmsg = msgPeek_;
fPeekKeep_ = false;
return true;
}
// Get w/wait + timer scan / dispatch + socket / event multiplexer dispatch
int cmsTotal = cmsWait;
int cmsElapsed = 0;
uint32 msStart = Time();
uint32 msCurrent = msStart;
while (true) {
// Check for sent messages
ReceiveSends();
// Check queues
int cmsDelayNext = kForever;
{
CritScope cs(&crit_);
// Check for delayed messages that have been triggered
// Calc the next trigger too
while (!dmsgq_.empty()) {
if (msCurrent < dmsgq_.top().msTrigger_) {
cmsDelayNext = dmsgq_.top().msTrigger_ - msCurrent;
break;
}
msgq_.push(dmsgq_.top().msg_);
dmsgq_.pop();
}
// Check for posted events
while (!msgq_.empty()) {
*pmsg = msgq_.front();
if (pmsg->ts_sensitive) {
long delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
if (delay > 0) {
LOG_F(LS_WARNING) << "id: " << pmsg->message_id << " delay: "
<< (delay + kMaxMsgLatency) << "ms";
}
}
msgq_.pop();
if (MQID_DISPOSE == pmsg->message_id) {
ASSERT(NULL == pmsg->phandler);
delete pmsg->pdata;
continue;
}
return true;
}
}
if (fStop_)
break;
// Which is shorter, the delay wait or the asked wait?
int cmsNext;
if (cmsWait == kForever) {
cmsNext = cmsDelayNext;
} else {
cmsNext = cmsTotal - cmsElapsed;
if (cmsNext < 0)
cmsNext = 0;
if ((cmsDelayNext != kForever) && (cmsDelayNext < cmsNext))
cmsNext = cmsDelayNext;
}
// Wait and multiplex in the meantime
ss_->Wait(cmsNext, true);
// If the specified timeout expired, return
msCurrent = Time();
cmsElapsed = msCurrent - msStart;
if (cmsWait != kForever) {
if (cmsElapsed >= cmsWait)
return false;
}
}
return false;
}
Get方法如同注释所说主要做了以下几件事情。
1. 如果已经有消息被Peek，那么取出那条消息直接返回ok了，并且把PeekKeep的标志置为false。
2. 先去delayed队列取消息，看看有没有到时的消息。 如果有，就放到主消息队列中去。
3. 去主消息队列中取消息，如果有，就直接返回ok了，没有的话继续以下步骤。这边又有一个删除消息的消息，如果收到的是刚才那样一个消息的话，就需要执行dispose操作。
4. 查看stop标志，如果不结束的话就利用余下的时间就进行多路复用器的监听工作，来监听异步网络事件。看到这条的时候就明白为什么要在Post消息的时候WakeUp多路复用器了，快速响应消息是王道啊！
Peek消息:
Peek消息其实是查看消息，再去取的时候还能够得到该条消息。我一开始以为message不会从队列中Pop出来，不过这边他采取类似的做法。设一个消息变量来保存Peeked的msg，一个标志peekKeep_来表示消息是否被Peek出来保存到变量中。因此，当peekKeep_为true 的时候，Get一下会取出变量里面的那条消息并且将标志置为false。
其他一些函数实现也比较基础，简单，这边就不说消息队列这个无聊的东西了。
三 SocketServer
接下去我们看看我最感兴趣的SocketServer了。
libjingle是gtalk的客户端，和服务器的底层socket通信主要就是使用了这个接口。
1. Socket:
SocketServer首先是个SocketFactory，所以它能Create出socket来，可以创建阻塞的和非阻塞的socket。
而创建出来的Socket则是对于不同os底层socket的高层抽象。
主要有Bind(), Connect(), Send(), Recv()等等。
而AsyncSocket则是有一些多了一些信号事件来给外界捕捉处理。
class AsyncSocket : public Socket, public sigslot::has_slots<> {
public:
virtual ~AsyncSocket() {}
sigslot::signal1<AsyncSocket*> SignalReadEvent; // ready to read
sigslot::signal1<AsyncSocket*> SignalWriteEvent; // ready to write
sigslot::signal1<AsyncSocket*> SignalConnectEvent; // connected
sigslot::signal2<AsyncSocket*,int> SignalCloseEvent; // closed
// TODO: error
};
这边用到了signal/slot机制，这个机制很棒，以前如果用过QT的朋友肯定能懂，和QT的signal/slot机制基本类似，libjingle里面的signal/slot库我还没来得及分析，不过短小精悍，应该不错，以后有机会再分析下，呵呵。 不过最重要的就是知道这个是一个类似与Observer模式的东西，最重要的就是其你发一个一开始有一个signal和一些slots用connect函数来绑定，signal就是被观察者，slot就是观察者。 如果有当signal触发的时候，slot就能接受到。
SocketServer是对监听网络事件的高层抽象，主要有两个函数:Wait()和Wakeup()。 监听的时候是Wait（），可以用WakeUp()来唤醒。
这里我们主要用到了异步的客户端。使用了select 多路复用器来监听异步网络事件。
当然抽象的好处就是可以有不同的实现，甚至是虚拟mock的实现。
而我们一般默认用到的就是PhysicalSocketServer，这个类封装了不同os之间网络库的差异性。
对于常用的一些socket函数的封装在这里我就不介绍了，主要介绍一下Wait()和Wakeup()函数中的工作机制。这边以linux为例子。
1. Dispatcher:
class Dispatcher {
public:
virtual uint32 GetRequestedEvents() = 0; // 返回感兴趣的事件
virtual void OnPreEvent(uint32 ff) = 0; // 在事件执行前
virtual void OnEvent(uint32 ff, int err) = 0; // 在事件执行时
virtual int GetDescriptor() = 0; // 返回Dispather的描述
};
这边引入了一个Dispatcher的概念，Dispatcher是用来派发事件的，因此对于多路复用器的主循环来说我们可以引入一个做法: 即当我们收到事件后我们使用不同的Dispatcher来进行派发，这里的事件可以是网络事件，也可以是其他可以被多路复用器选择出来的事件。
我们先来看网络事件派发器SocketDispatcher。
它主要是继承了PhysicalSocket和Dispatcher，然后在派发执行函数OnEvent()里面进行异步网络事件通知处理，signal感兴趣的 网络连接，读，写，关闭事件，并且将更新感兴趣的网络事件，去除已经做过的事件。
virtual void OnEvent(uint32 ff, int err) {
int cache_id = id_;
if ((ff & kfRead) != 0) {
enabled_events_ &= ~kfRead;
SignalReadEvent(this);
}
if (((ff & kfWrite) != 0) && (id_ == cache_id)) {
enabled_events_ &= ~kfWrite;
SignalWriteEvent(this);
}
if (((ff & kfConnect) != 0) && (id_ == cache_id)) {
if (ff != kfConnect)
LOG(LS_VERBOSE) << "Signalled with kfConnect: " << ff;
enabled_events_ &= ~kfConnect;
SignalConnectEvent(this);
}
if (((ff & kfClose) != 0) && (id_ == cache_id)) {
//LOG(INFO) << "SOCK[" << static_cast<int>(s_) << "] OnClose() Error: " << err;
signal_close_ = true;
signal_err_ = err;
}
}
还有一种就是其他的事件分派器， EventDispatcher在linux下面是用了pipe来模拟(windows则有event机制)。这样也可以被多路复用器select出来。
Signal的时候从一端往管道中写，而在PreOnEvent的时候从另一端读出来。
这边一个实例就是类Signaler。 该类继承了EventDispatcher来完成对退出wait，达到wakeup。
2. wait()函数详解:
这里我贴了一段wait()的linux实现代码，不包括里面的超时机制。
// Zero all fd_sets. Don't need to do this inside the loop since
// select() zeros the descriptors not signaled
fd_set fdsRead;
FD_ZERO(&fdsRead);
fd_set fdsWrite;
FD_ZERO(&fdsWrite);
fWait_ = true;
while (fWait_) {
int fdmax = -1;
{
CritScope cr(&crit_);
for (unsigned i = 0; i < dispatchers_.size(); i++) {
// Query dispatchers for read and write wait state
Dispatcher *pdispatcher = dispatchers_[i];
assert(pdispatcher);
if (!process_io && (pdispatcher != signal_wakeup_))
continue;
int fd = pdispatcher->GetDescriptor();
if (fd > fdmax)
fdmax = fd;
uint32 ff = pdispatcher->GetRequestedEvents();
if (ff & kfRead)
FD_SET(fd, &fdsRead);
if (ff & (kfWrite | kfConnect))
FD_SET(fd, &fdsWrite);
}
}
// Wait then call handlers as appropriate
// < 0 means error
// 0 means timeout
// > 0 means count of descriptors ready
int n = select(fdmax + 1, &fdsRead, &fdsWrite, NULL, ptvWait);
// If error, return error
// todo: do something intelligent
if (n < 0)
return false;
// If timeout, return success
if (n == 0)
return true;
// We have signaled descriptors
{
CritScope cr(&crit_);
for (unsigned i = 0; i < dispatchers_.size(); i++) {
Dispatcher *pdispatcher = dispatchers_[i];
int fd = pdispatcher->GetDescriptor();
uint32 ff = 0;
if (FD_ISSET(fd, &fdsRead)) {
FD_CLR(fd, &fdsRead);
ff |= kfRead;
}
if (FD_ISSET(fd, &fdsWrite)) {
FD_CLR(fd, &fdsWrite);
if (pdispatcher->GetRequestedEvents() & kfConnect) {
ff |= kfConnect;
} else {
ff |= kfWrite;
}
}
if (ff != 0) {
pdispatcher->OnPreEvent(ff);
pdispatcher->OnEvent(ff, 0);
}
}
}
1. 创建 fd_set并且初始化。
2. 对每个dispatcher的fd添加感兴趣的事件。
3. select()。
4. 更新每个dispatcher的感兴趣的并且发生的事件到ff，然后执行OnPreEvent和OnEvent。
浙公网安备 33010602011771号