http://www.artima.com/articles/io_design_patterns.html
转载自：http://www.cppblog.com/kevinlynx/archive/2008/06/06/52356.html
Proactor和Reactor模式_继续并发系统设计的扫盲
6.6.2008
Kevin Lynx
Proactor和Reactor都是并发编程中的设计模式。在我看来，他们都是用于派发/分离IO操作事件的。这里所谓的
IO事件也就是诸如read/write的IO操作。"派发/分离"就是将单独的IO事件通知到上层模块。两个模式不同的地方
在于，Proactor用于异步IO，而Reactor用于同步IO。
摘抄一些关键的东西：
"
Two patterns that involve event demultiplexors are called Reactor and Proactor [1]. The Reactor patterns
involve synchronous I/O,whereas the Proactor pattern involves asynchronous I/O.
"
关于两个模式的大致模型，从以下文字基本可以明白：
"
An example will help you understand the difference between Reactor and Proactor. We will focus on the read
operation here,as the write implementation is similar. Here's a read in Reactor:
* An event handler declares interest in I/O events that indicate readiness for read on a particular socket ;
* The event demultiplexor waits for events ;
* An event comes in and wakes-up the demultiplexor,and the demultiplexor calls the appropriate handler;
* The event handler performs the actual read operation,handles the data read,declares renewed interest in
I/O events,and returns control to the dispatcher .
By comparison,here is a read operation in Proactor (true async):
* A handler initiates an asynchronous read operation (note: the OS must support asynchronous I/O). In this
case,the handler does not care about I/O readiness events,but is instead registers interest in receiving
completion events;
* The event demultiplexor waits until the operation is completed ;
* While the event demultiplexor waits,the OS executes the read operation in a parallel kernel thread,puts
data into a user-defined buffer,and notifies the event demultiplexor that the read is complete ;
* The event demultiplexor calls the appropriate handler;
* The event handler handles the data from user defined buffer,starts a new asynchronous operation,and returns
control to the event demultiplexor.
"
可以看出，两个模式的相同点，都是对某个IO事件的事件通知(即告诉某个模块，这个IO操作可以进行或已经完成)。在结构
上，两者也有相同点：demultiplexor负责提交IO操作(异步)、查询设备是否可操作(同步)，然后当条件满足时，就回调handler。
不同点在于，异步情况下(Proactor)，当回调handler时，表示IO操作已经完成；同步情况下(Reactor)，回调handler时，表示
IO设备可以进行某个操作(can read or can write)，handler这个时候开始提交操作。
用select模型写个简单的reactor，大致为：
classhandler
{
public:
virtualvoidonRead()=0;
voidonWrite()=0;
voidonAccept()=0;
};
classdispatch
{
voidpoll()
{
//addfdintheset.
polleveryfdintc=select(0,&read_fd,&write_fd,0);
if(c>0)
{
foreachfdintheread_fd_set
{iffdcanread
_handler->onRead();
iffdcanaccept
_handler->onAccept();
}
inthewrite_fd_set
{
iffdcanwrite
_handler->onWrite();
}
}
}
voidsetHandler(handler*_h)
{
_handler=_h;
}
private:
handler*_handler;
};
///application
classMyHandler: publichandler
{
voidonRead()
{
}
voidonWrite()
{
}
voidonAccept()
{
}
};
在网上找了份Proactor模式比较正式的文档，其给出了一个总体的UML类图，比较全面：
根据这份图我随便写了个例子代码：
classAsyIOProcessor
{
voiddo_read()
{
sendreadoperationtoOS
readiofinished.anddispatchnotification
_proactor->dispatch_read();
}
private:
Proactor*_proactor;
};
classProactor
{
voiddispatch_read()
{
_handlerMgr->onRead();
}
private:
HandlerManager*_handlerMgr;
};
classHandlerManager
{
public:
typedefstd::list<Handler*>HandlerList;
voidonRead()
{
notifyallthehandlers.
std::for_each(_handlers.begin(),_handlers.end(),onRead);
}
private:
HandlerList*_handlers;
};
classHandler
{
voidonRead()=0;
};
//
applicationlevelhandler.
publicHandler
{
voidonRead()
{
}
};
