目的

Multiplexing 和 Demultiplexing 是专有技术名词不知道怎么翻译比较合适。 Multiplexing：暂时翻译为多路复用，指的是在源主机，传输层协议从不同的套接字（Socket）收集应用进程（Process）要发送的数据块，并为每个数据块封装上首部信息（包括用于分解的信息）构成报文段，然后将报文段传递给网络层 Demultiplexing：暂时译为多路分离，指的是在目的主机，传输层协议读取报文段中的字段，标识出接收的套接字，进而通过该套接字，将传输层的报文段中的数据交付给正确的套接字

别称

例子

• 效率：因为上下文切换、同步和数据移动，多线程可能会导致性能低下

• 易于编程：多线程可能需要复杂的并发控制方案

• 可移植性：多线程并不是所有操作系统平台都可用

上下文

问题

• 可用性：服务器即便是在等待其他请求到来时，也要保持对处理到来的请求可用。特别是，服务器不能在排除其他事件源的情况下无限期地阻止处理任何单个事件源，因为这可能会显著延迟对其他客户端的响应。

• 效率：服务器必须最小化延迟、最大化吞吐量，并避免不必要地使用 CPU。

• 易于编程：服务器的设计应该简化合适的并发策略的使用。

• 可变性：集成新的或者改进的服务，如改变消息格式户这话添加服务端缓存，应该给现有的代码带来较少的修改和维护成本。举个例子，实现一个新的应用服务不应该需要修改通用的事件多路分离和分派机制。

• 移植性：将服务器移植到新的操作系统平台不应该需要太多的工作量。

解决方案

Integrate the synchronous demultiplexing of events and the dispatching of their corresponding event handlers that process the events. In addition, decouple the application-specific dispatching and implementation of services from the general-purpose event demultiplexing and dispatching mechanisms.

结构

Handles 句柄

• 标识操作系统管理的资源，这些资源一般包括网络连接、打开的文件、计时器和同步对象等。在日志服务器中 Handles 用来标识 Synchronous Event Demultiplexer 用来等待事件发生的套接字端口（socket endpoint）。日志服务器感兴趣的两种事件是 connection 事件和 read 事件，它们分别代表传入的客户端连接和日志记录数据。日志服务器为每个客户端维护一个连接，这些连接在服务器中用套接字句柄指代。【注：跟 Windows 平台的句柄和 Linux 平台的文件描述符是类似的概念】

Synchronous Event Demultiplexer 同步事件多路分离器

• Synchronous Event Demultiplexer 是在一组句柄上等待事件发生的数据块（Blocks），当可以在不阻塞的情况下启动对句柄的操作时，该数据块就会返回。一个常见的 I/O 事件的多路分离器是由 UNIX 和 Win32 操作系统平台提供的事件多路分离系统调用（system call）select，它会显示出那些进行同步操作调用也不会阻塞应用程序进程的句柄。

Initiation Dispatcher 初始分发器

• Initiation Dispatcher 定义了登记、移除和分派 Event Handler 的接口。总的来看，Synchronous Event Demultiplexer 负责等待新事件的发生，当它发现新事件时，会通知 Initiation Dispatcher 去回调特定于应用程序的事件处理器。常见的事件包括连接接受事件、数据输入和输出事件以及超时事件。

Event Handler 事件处理器

• 事件处理器指定一个由钩子方法组成的接口，它抽象地表示特定于服务的事件的调度操作。该方法必须被特定于应用程序的服务实现。

Concrete Event Handler 具体的事件处理器

• 具体的事件处理器实现了事件处理器的钩子方法，同时也实现了使用特定于应用的方式处理事件的方法。应用程序向 Initiation Dispatcher 登记具体事件处理器来处理特定类型的事件，当事件到达时，Initiation Dispatcher 会回调适合的具体事件处理器的钩子方法。
在日志服务器中有两种具体的事件处理器：Logging Handler 和 Logging Acceptor，Logging Handler 负责接收和处理日志记录数据，Logging Acceptor 把创建并连接 Logging Handlers，用于处理来自客户端的后续日志记录。

动机

常用协作

• 当应用程序向 Initiation Dispatcher 登记具体的事件处理器（Concrete Event Handler）的时候，应用程序会指明该 Event Handler 希望 Initiation Dispatcher 在关联的句柄上发生事件的时候通知它的事件类型。

• Initiation Dispatcher 要求每个 Event Handler 都把它内部的句柄返回给自己，这个句柄标识着操作系统里的 Event Handler。

• 等到所有的 Event Handler 登记之后，应用程序调用 handle_events 开启 Initiation Dispatcher 的事件循环。此时，Initiation Dispatcher 组合来自每个注册过的 Event Handler 的句柄，并使用 Synchronous Event Demultiplexer 等待事件在这些句柄上发生。比如，在 TCP 协议层使用 select 这个同步事件多路分离操作来等待客户端 Logging Record 事件在建立连接的套接字句柄上到来。

• 当与事件源对应的句柄“就绪”时， Synchronous Event Demultiplexer 会通知 Initiation Dispatcher，比如当 TCP 套接字“读就绪”时。

• Initiation Dispatcher 触发 Event Handler 的钩子方法【注：图中的 handle_event(type)】来响应就绪句柄上的事件。当事件发生时，Initiation Dispatcher 使用被事件源激活的句柄作为“键”来定位和分派Event Handler中合适的钩子方法。

• Initiation Dispatcher 调用 handle_event 这个 Event Handler 中的钩子方法来执行特定于应用的功能作为对事件的响应，发生的事件类型可以作为参数传进这个钩子方法，同时可以被这个方法内部使用来执行额外的特定于服务的多路分离和分派。其他可选的分派方案会在 9.4 部分阐述。

协作场景

客户端连接到响应式日志服务器

1. 日志服务器（1）向 Initiation Dispatcher 注册 Logging Acceptor 来处理连接请求；

2. 日志服务器掉用Initiation Dispatcher 的 handle_events 方法（2）；

3. Initiation Dispatcher 调用同步事件多路分离操作 select（3）来等待连接请求或者日志数据到达；

4. 客户端连接（4）到日志服务器

5. Logging Acceptor 会收到 Initiation Dispatcher （5）关于这个新连接请求的通知；

6. Logging Acceptor 接收（6）这个新的连接；

7. Logging Acceptor 创建（7）一个 Logging Handler 来服务这个新的客户端；

8. Logging Handler 向 Initiation Dispatcher 注册（8）他的套接字句柄，并指示分发器当这个套接字“读就绪”的时候通知它。

客户端向响应式日志服务器发送日志记录数据

1. 客户端发送（1）一个日志记录数据；

2. 当客户端的日志记录被操作系统加入套接字句柄的队列时，Initiation Dispatcher 会通知（2）套接字句柄关联的 Logging Handler ；

3. 记录被以非阻塞的方式接收（3）（步骤 2 和步骤 3 重复进行，直到日志记录被完全接收）；

4. Logging Handler 处理日志记录，并把结果写入（4）标准输出；

5. Logging Handler 将控制权交给（5） Initiation Dispatcher 的事件循环。

实现

选择 Synchronous Event Demultiplexer 机制

开发 Initiation Dispatcher

enum Event_Type
// = TITLE
// Types of events handled by the Initiation_Dispatcher.
// = DESCRIPTION
// These values are powers of two so their bits can be efficiently ‘‘or’d’’
// together to form composite values.
{
  ACCEPT_EVENT = 01,
  READ_EVENT = 02,
  WRITE_EVENT = 04,
  TIMEOUT_EVENT = 010,
  SIGNAL_EVENT = 020,
  CLOSE_EVENT = 040
};
class Initiation_Dispatcher
// = TITLE
// Demultiplex and dispatch Event_Handlers in response to client requests.
{
public:
  // Register an Event_Handler of a particular Event_Type (e.g., READ_EVENT, ACCEPT_EVENT, etc.).
  int register_handler (Event_Handler *eh, Event_Type et);
  // Remove an Event_Handler of a particular Event_Type.
  int remove_handler (Event_Handler *eh, Event_Type et);
  // Entry point into the reactive event loop.
  int handle_events (Time_Value *timeout = 0);
};

决定分派目标的类型

定义事件处理接口

class Event_Handler
// = TITLE
// Abstract base class that serves as the
// target of the Initiation_Dispatcher.
{
public:
  // Hook method that is called back by the
  // Initiation_Dispatcher to handle events.
  virtual int handle_event (Event_Type et) = 0;
  // Hook method that returns the underlying I/O Handle.
  virtual Handle get_handle (void) const = 0;
};

class Event_Handler
{
public:
  // Hook methods that are called back by
  // the Initiation_Dispatcher to handle
  // particular types of events.
  virtual int handle_accept (void) = 0;
  virtual int handle_input (void) = 0;
  virtual int handle_output (void) = 0;
  virtual int handle_timeout (void) = 0;
  virtual int handle_close (void) = 0;
  // Hook method that returns the underlying I/O Handle.
  virtual Handle get_handle (void) const = 0;
};

决定 Initiation Dispatchers 的数量

实现具体的事件处理器

class Logging_Acceptor : public Event_Handler
// = TITLE
// Handles client connection requests.
{
public:
  // Initialize the acceptor_ endpoint and
  // register with the Initiation Dispatcher.
  Logging_Acceptor (const INET_Addr &addr);
  // Factory method that accepts a new
  // SOCK_Stream connection and creates a
  // Logging_Handler object to handle logging
  // records sent using the connection.
  virtual void handle_event (Event_Type et);
  // Get the I/O Handle (called by the
  // Initiation Dispatcher when
  // Logging_Acceptor is registered).
  virtual HANDLE get_handle (void) const
  {
  	return acceptor_.get_handle ();
  }
private:
  // Socket factory that accepts client connections.
  SOCK_Acceptor acceptor_;
};

Logging_Acceptor::Logging_Acceptor(const INET_Addr &addr) : acceptor_ (addr)
{
	// Register acceptor with the Initiation
	// Dispatcher, which "double dispatches"
	// the Logging_Acceptor::get_handle() method
	// to obtain the HANDLE.
	Initiation_Dispatcher::instance()-> register_handler (this, ACCEPT_EVENT);
}

void Logging_Acceptor::handle_event (Event_Type et)
{
	// Can only be called for an ACCEPT event.
	assert (et == ACCEPT_EVENT);
	SOCK_Stream new_connection;
	// Accept the connection.
	acceptor_.accept (new_connection);
	// Create a new Logging Handler.
	Logging_Handler *handler = new Logging_Handler (new_connection);
}

class Logging_Handler : public Event_Handler
// = TITLE
// Receive and process logging records
// sent by a client application.
{
public:
	// Initialize the client stream.
	Logging_Handler (SOCK_Stream &cs);
	// Hook method that handles the reception
	// of logging records from clients.
	virtual void handle_event (Event_Type et);
	// Get the I/O Handle (called by the
	// Initiation Dispatcher when
	// Logging_Handler is registered).
	virtual HANDLE get_handle (void) const
	{
		return peer_stream_.get_handle ();
	}
private:
	// Receives logging records from a client.
	SOCK_Stream peer_stream_;
};

Logging_Handler::Logging_Handler(SOCK_Stream &cs) : peer_stream_ (cs)
{
	// Register with the dispatcher for
	// READ events.
	Initiation_Dispatcher::instance ()-> register_handler (this, READ_EVENT);
}

void Logging_Handler::handle_event (Event_Type et)
{
	if (et == READ_EVENT) {
		Log_Record log_record;
		peer_stream_.recv ((void *) log_record, sizeof log_record);
		// Write logging record to standard output.
		log_record.write (STDOUT);
	}
	else if (et == CLOSE_EVENT) {
		peer_stream_.close ();
		delete (void *) this;
	}
}

实现服务器

// Server port number.
const u_short PORT = 10000;
int main (void)
{
	// Logging server port number.
	INET_Addr server_addr (PORT);
	// Initialize logging server endpoint and
	// register with the Initiation_Dispatcher.
	Logging_Acceptor la (server_addr);
	// Main event loop that handles client
	// logging records and connection requests.
	for (;;)
		Initiation_Dispatcher::instance ()-> handle_events ();
	/* NOTREACHED */return 0;
}

结论

好处

不足