ACE框架解读 - 源码篇

最近研究了ACE框架的源码，先考虑选取最新版本ACE6.0来读，但是发现代码量有30多万行，规模太大了花的时间会比较多，所以考虑选取旧一些的版本，最后选取ACE4.5版本来阅读，代码量13万行比较适中。

下面是我读代码时的一些总结，把所有的目录和文件列出来，并针对每个文件里的主要类及其实现，根据自己的理解作了一些总结。

文件

总结

[CORBA]

COBRA整体略过。

CORBA_Handler.cpp

CORBA_Handler.h

CORBA_Handler.i

　

CORBA_Ref.cpp

CORBA_Ref.h

CORBA_Ref.i

　

[Collections]

　

Array.cpp

Array.h

Array.i

普通数组类，封装了数组相关操作。

Containers.cpp

Containers.i

Containers.h

节点类：单向链表节点、双向链表节点。

容器类：动态数组栈、静态数组栈、动态链表栈、动态链表队列、双向链表、动态链表键、静态数组键、动态数组键、有序双向链表键。

迭代器类：动态链表栈迭代器、动态链表队列迭代器、双向链表迭代器、动态链表键迭代器、静态数组键迭代器、动态数组键迭代器、有序双向链表键迭代器。

Hash_Map_Manager.cpp

Hash_Map_Manager.h

哈希表关联数组类，使用哈希表存储对象并索引键值，哈希表每个节点使用一个环形链表来存储冲突的对象，还实现了一个正向和反向的迭代器。

Filecache.cpp

Filecache.h

文件读写管理类，实现了读对象的共享，用读写锁来控制文件读写并发，用哈希表来索引同一个文件的多个读写对象。

ACE_Filecache类的成员变量stale_处理逻辑有问题，且未被其他类使用。

Free_List.cpp

Free_List.i

Free_List.h

预分配待使用链表抽象基类，包含高低水位标志，保持链表节点保持不高于高水位，当低于低水位时再次分配一定数量的节点。

Managed_Object.cpp

Managed_Object.h

Managed_Object.i

对象模板抽象基类，包含获取对象接口和释放接口。

Map_Manager.cpp

Map_Manager.h

Map_Manager.i

普通关联数组类，使用数组来存储对象，也实现了一个正向和反向的迭代器。

Object_Manager.cpp

Object_Manager.i

Object_Manager.h

对象管理类，生成一批静态锁对象，供其他类使用，同时也可以生成一些单件锁对象，供单件对象使用，并且管理这些锁对象的创建与释放。

SString.cpp

SString.h

SString.i

字符串类，封装了字符串对象的系列操作。

单词类，把一个长字符串分割成一个个单词来返回。

[Concurrency]

　

Activation_Queue.cpp

Activation_Queue.h

方法对象队列类，对消息队列做了少量封装。

Atomic_Op.i

　

Future.cpp

Future.h

异步操作结果类，对异步操作结果进行的通用性封装，还包含了多一个结果引用同一个实际对象的引用相关处理。

Method_Object.cpp

Method_Object.h

方法对象基类，定义了一个方法对象的空壳。

Process.cpp

Process.h

Process.i

进程类，封装了操作系统进程相关操作，以及进程环境变量和参数。

Process_Manager.cpp

Process_Manager.h

Process_Manager.i

进程描述类，描述id和组id等信息，用来表示一个进程。

进程管理类，封装了线程的创建及后续生命期的相关操作及管理。

Sched_Params.cpp

Sched_Params.h

Sched_Params.i

优先级参数类，封装了线程、进程优先级参数的相关操作。

Synch.cpp

Synch.h

Synch.i

同步对象类，封装了一系列线程、进程间通信对象，如：互斥锁、记录锁、信号量、读写锁、条件变量、守卫（对象离开生存期自动释放）、等待事件（Win32）、递归锁、栅栏（指定数量的对象都处于等待状态后才继续运行）。

自动事件：当处于Signal状态时,只有一个等待该事件的线程会被唤醒，之后事件会被自动回到Non Signal状态。

手动事件：当处于Signal状态时,所有等待该事件的线程都会被唤醒，之后需要调用ResetEvent把Event对象调回到Non Signal状态。

Synch_Options.cpp

Synch_Options.h

Synch_Options.i

同步参数类，封装了同步参数对象的设置和获取相关操作。

Synch_T.cpp

Synch_T.h

Synch_T.i

同步对象模板类，包括：

锁适配器类，在锁基础上封装了一层标准操作。

标志位类，封装了对标志位的置位和测试操作。

算术操作类，封装了对象的算术操作。

线程专有存储类，封装了线程专有存储机制。

守卫类，封装了对同步对象的的相关操作，以及对象离开生存期自动释放机制。

条件变量类，封装了条件对象相关机制。

Thread.cpp

Thread.h

Thread.i

线程类，封装了操作系统线程相关的操作，都是静态成员函数，供需要进行线程操作的程序使用。

Thread_Manager.cpp

Thread_Manager.h

Thread_Manager.i

线程描述类，包含了线程id及相关信息，用来表示一个线程。

线程管理类，负责线程的创建及后续整个线程生命期的管理。

线程适配类（ACE_Thread_Adapter），对线程入口函数进行的封装。

Token.cpp

Token.h

Token.i

增强型同步类，多个服务获取锁时处于等待状态，采用队列结构来存储这些服务，然后按FIFO方式来唤醒这些队列中的服务。

[Config]

　

config.h

　

Basic_Types.cpp

Basic_Types.h

Basic_Types.i

定义了一种无符号128bit宽度的数据类型。

Version.h

　

[Connection]

　

Acceptor.cpp

Acceptor.h

Acceptor.i

接受器工厂类，对接受对象进行了封装，结合反应器，形成服务对象的概念，能够调用接受对象进行实际的接受连接动作，并且能够挂载到反应器上进行处理，同时满足服务对象的挂起、恢复、启动、停止等动作。

策略接受器工厂类，对接受器的创建、接受、激活、调度等动作委托到相应的策略类进行处理。

单连接接受工厂类，只接受一个连接的接受器类。

Asynch_Acceptor.cpp

Asynch_Acceptor.h

Asynch_Acceptor.i

异步接收器工厂类，结合前摄器，实现异步接受连接相关的处理。

Asynch_IO.cpp

Asynch_IO.h

Asynch_IO.i

在前摄器模式中使用

异步操作结果基类，定义了异步操作结果包含的基本要素和操作接口。

异步操作基类，定义了异步操作的基本接口。

异步流读类，定义了异步流读接口以及相应的完成处理。

异步流写类，定义了异步流写接口以及相应的完成处理。

异步文件读类，定义了异步文件读接口以及相应的完成处理。

异步文件写类，定义了异步文件写接口以及相应的完成处理。

异步接收类，定义了异步接收接口以及相应的完成处理。

异步文件传输类，定义了异步文件传输接口以及相应的完成处理。

句柄类，定义了接受到异步操作完成结果后的操作接口。

服务句柄类，定义了异步接受操作完成后的操作接口。

Connector.cpp

Connector.h

Connector.i

连接工厂类，对连接对象进行封装，结合反应器，形成服务对象的概念，能够创建连接对象并且连接到对端，当采用非阻塞IO时，能把连接句柄挂载到反应器上，并在自身内部映射表保存一个条目，当非阻塞IO操作完成时，通过反应器回调处理函数到映射表找到那个条目，进而完成处理。

策略连接工厂类，把连接器的创建、连接、激活等动作委托到相应的策略类进行处理。

Dynamic_Service.cpp

Dynamic_Service.h

Dynamic_Service.i

动态服务类，定义了通过一个名称在服务容器查找到相应的服务，进而返回关联在服务上的服务对象。

Strategies.cpp

Strategies.h

Strategies.i

通知策略基类，定义了通知策略的基本接口。
反应器通知策略类，定义了通知反应器的策略的基本接口。

连接重利用策略类，定义了连接重利用策略的基本接口。

Strategies_T.cpp

Strategies_T.h

Strategies_T.i

重利用策略类，定义了服务对象的连接重利用策略的分配和启动接口。

创建策略类，定义了服对象务的创建接口。
单件模式创建策略类，定义了服务对象的单件模式创建操作。

动态链接模式创建策略类，定义了服务对象在动态链接库情况下的创建操作。

并发策略类，定义了服务对象的并发激活接口。
反应器并发策略类，定义了服务对象依托反应器情况下的激活操作。

多线程并发策略类，定义了服务对象在多线程情况下的激活操作。

多进程并发策略类，定义了服务对象在多进程情况下的激活操作。

接受器策略类，定义了被动连接接受器的接受动作接口。

连接器策略类，定义了主动连接器的连接动作接口。
调度策略类，定义了服务对象挂起、恢复调度接口。
哈希地址类，定义了地址对象的哈希计算和比较接口。
连接缓存类，能够调用创建策略类创建服务对象，然后调用并发策略类激活对象，然后将对象缓存在内部哈希表中，最后调用重利用策略类分配连接重利用策略，并支持相关的重利用动作。

反应器调度策略类，定义了依托反应器情况下的服务对象挂起、恢复调度操作。

多线程调度策略类，定义了多线程情况下的服务对象挂起、恢复调度操作。

Svc_Handler.cpp

Svc_Handler.h

Svc_Handler.i

连接服务基类，用于跟连接对端进行数据交互，为此定义了一些接口和基本机制，并支持重利用。

[IPC]

　

[IPC/IO_SAP]

　

IO_SAP.cpp

IO_SAP.h

IO_SAP.i

IO类型对象基类，定义了各类IO对象的基本行为。

[IPC/IO_SAP/DEV_SAP]

　

DEV.cpp

DEV.h

DEV.i

设备基类，定义了设备的基本行为。

DEV_Connector.cpp

DEV_Connector.h

DEV_Connector.i

客户端设备类，定义了设备类型的客户端连接操作。

DEV_IO.cpp

DEV_IO.h

DEV_IO.i

设备类，定义了设备的数据收发操作。

TTY_IO.cpp

TTY_IO.h

串口类，定义了串口类型设备的控制操作。

[IPC/IO_SAP/FILE_SAP]

　

FILE.cpp

FILE.h

FILE.i

文件基类，定义了文件类型对象的通用操作。

FILE_Connector.cpp

FILE_Connector.h

FILE_Connector.i

客户端文件类，定义了文件的打开操作。

FILE_IO.cpp

FILE_IO.h

FILE_IO.i

文件类，定义了文件的相关收发操作。

[IPC/IPC_SAP]

　

IPC_SAP.cpp

IPC_SAP.h

IPC_SAP.i

进程间通信基类，定义了进程间通信对象的基本行为。

[IPC/IPC_SAP/Addr]

　

Addr.cpp

Addr.h

Addr.i

地址基类，定义地址对象的基本行为。

DEV_Addr.cpp

DEV_Addr.h

DEV_Addr.i

设备地址类，定义设备地址对象的相关行为。

FILE_Addr.cpp

FILE_Addr.h

FILE_Addr.i

文件地址类，定义了文件地址对象的相关行为。

INET_Addr.cpp

INET_Addr.h

INET_Addr.i

套接字地址类，定义了套接字地址对象的相关行为。

SPIPE_Addr.cpp

SPIPE_Addr.h

SPIPE_Addr.i

流管道地址类，定义了流管道地址对象的相关行为。

UNIX_Addr.cpp

UNIX_Addr.h

UNIX_Addr.i

UNIX套接字地址类，定义了UNIX套接字地址对象的相关行为。

UPIPE_Addr.h

　

[IPC/IPC_SAP/FIFO_SAP]

　

FIFO.cpp

FIFO.h

FIFO.i

有名管道类，定义有名管道对象的创建销毁操作。

FIFO_Recv.cpp

FIFO_Recv.h

FIFO_Recv.i

有名管道接受端类，定义有名管道对象的接收操作。

FIFO_Recv_Msg.cpp

FIFO_Recv_Msg.h

FIFO_Recv_Msg.i

有名管道接受端增强类，定义有名管道对象的接收操作。

FIFO_Send.cpp

FIFO_Send.h

FIFO_Send.i

有名管道发送端类，定义有名管道对象的发送操作。

FIFO_Send_Msg.cpp

FIFO_Send_Msg.h

FIFO_Send_Msg.i

有名管道发送端增强类，定义有名管道对象的发送操作。

[IPC/IPC_SAP/SOCK_SAP]

　

LOCK_SOCK_Acceptor.cpp

LOCK_SOCK_Acceptor.h

　

LSOCK.cpp

LSOCK.h

LSOCK.i

本地套接字类，用来传递文件描述符。

LSOCK_Acceptor.cpp

LSOCK_Acceptor.h

LSOCK_Acceptor.i

本地流套接字服务端，定义了本地套接字服务器行为。

LSOCK_CODgram.cpp

LSOCK_CODgram.h

LSOCK_CODgram.i

本地连接数据报套接字类，定义本地带连接的数据报套接字的操作。

LSOCK_Connector.cpp

LSOCK_Connector.h

LSOCK_Connector.i

本地流套接字客户端，定义了本地套接字客户器行为。

LSOCK_Dgram.cpp

LSOCK_Dgram.h

LSOCK_Dgram.i

本地数据报套接字，定义了本地数据报套接字相关行为。

LSOCK_Stream.cpp

LSOCK_Stream.h

LSOCK_Stream.i

本地流套接字基类，定义了本地流套接字基本行为。

SOCK.cpp

SOCK.h

SOCK.i

套接字基类，定义套接字对象的基本行为。

SOCK_Acceptor.cpp

SOCK_Acceptor.h

SOCK_Acceptor.i

流套接字服务端类，定义了流套接字服务端的行为。

SOCK_CODgram.cpp

SOCK_CODgram.h

SOCK_CODgram.i

连接数据报套接字类，定义带连接的数据报套接字的操作。

SOCK_Connector.cpp

SOCK_Connector.h

SOCK_Connector.i

流套接字客户端类，定义流套接字客户端的行为。

SOCK_Dgram.cpp

SOCK_Dgram.h

SOCK_Dgram.i

数据报套接字，定义了数据报套接字相关行为。

SOCK_Dgram_Bcast.cpp

SOCK_Dgram_Bcast.h

SOCK_Dgram_Bcast.i

数据报广播套接字，定义了数据报广播套接字的相关行为。

SOCK_Dgram_Mcast.cpp

SOCK_Dgram_Mcast.h

SOCK_Dgram_Mcast.i

数据报多播套接字，定义了数据报多播套接字的相关行为。

SOCK_IO.cpp

SOCK_IO.h

SOCK_IO.i

套接字IO操作基类，定义了套接字对象的基本IO操作。

SOCK_Stream.cpp

SOCK_Stream.h

SOCK_Stream.i

流式套接字基类，定义了流式套接字基本行为。

[IPC/IPC_SAP/SPIPE_SAP]

　

SPIPE.cpp

SPIPE.h

SPIPE.i

流管道基类，定了流管道的创建销毁行为。

SPIPE_Acceptor.cpp

SPIPE_Acceptor.h

SPIPE_Acceptor.i

流管道服务端类，定义了流管道服务端的行为。

SPIPE_Connector.cpp

SPIPE_Connector.h

SPIPE_Connector.i

流管道客户端类，定义了流管道客户端的行为。

SPIPE_Stream.cpp

SPIPE_Stream.h

SPIPE_Stream.i

流管道IO操作类，定义了流管道IO相关操作。

[IPC/IPC_SAP/TLI_SAP]

　

TLI.cpp

TLI.h

TLI.i

TLI对象基类，定义了TLI对象的创建销毁行为。

TLI_Acceptor.cpp

TLI_Acceptor.h

TLI_Acceptor.i

TLI对象服务端类，定义了TLI对象服务端的行为。

TLI_Connector.cpp

TLI_Connector.h

TLI_Connector.i

TLI对象客户端类，定义了TLI对象客户端的行为。

TLI_Stream.cpp

TLI_Stream.h

TLI_Stream.i

TLI对象IO操作类，定义了TLI对象IO相关操作。

[IPC/UPIPE_SAP]

　

UPIPE_Acceptor.cpp

UPIPE_Acceptor.h

UPIPE_Acceptor.i

无连接管道服务端类，定义了无连接管道服务端的行为。

UPIPE_Connector.cpp

UPIPE_Connector.h

UPIPE_Connector.i

无连接管道客户端类，定义了无连接管道客户端的行为。

UPIPE_Stream.cpp

UPIPE_Stream.h

UPIPE_Stream.i

无连接管道IO操作类，定义了无连接管道IO相关操作。

[IPC/Utils]

　

IOStream.cpp

IOStream.h

流缓冲区类，基于标准库类streambuf基础上增强。
需要先了解标准库类streambuf的行为才能理解这个类，所以暂时未读懂。

这个类未被其他类使用。

IOStream_T.cpp

IOStream_T.h

IOStream_T.i

流读写类，在标准库的基础上定义了流读写相关操作。

Pipe.cpp

Pipe.h

Pipe.i

无名管道类，定义了无名管道的基本操作。

Signal.cpp

Signal.h

Signal.i

信号机制管理类，定义了一系列类包括：

信号集类，负责信号集相关的处理操作。

信号注册类，负责注册信号及其处理函数。

信号处理函数管理类，负责信号处理函数的统一入口分派。

信号处理函数类，负责具体对应某个信号的信号处理函数封装。

信号处理函数增强管理类，负责信号处理函数的统一入口分派，并且对于一个信号能够注册多个信号处理函数，在捕获到信号时能够一一被调用。

[Logging and Tracing]

　

Dump.cpp

Dump.h

对象dump管理类，负责统一管理各类对象对应的dump类。

Dump_T.cpp

Dump_T.h

dump泛型类，对抽象的dump类泛型化，以适应不同类型的对象。

Log_Msg.cpp

Log_Msg.h

Log_Msg.i

日志管理类，负责日志的格式化整理以及相关控制操作，以及输出到标准输出、远程日志服务器、流对象上。

Log_Priority.h

　

Log_Record.cpp

Log_Record.h

Log_Record.i

日志记录类，定义了一条日志记录相关信息及其操作。

Trace.cpp

Trace.h

Trace.i

函数调用跟踪类，负责打印每个函数的调用时的进入以及离开日志。

[Memory]

　

[Memory/Mem_Map]

　

Mem_Map.cpp

Mem_Map.h

Mem_Map.i

共享内存基类（ACE_Mem_Map），封装定义了共享内存相关操作和机制。

[Memory/Shared_Malloc]

　

Malloc.cpp

Malloc.h

Malloc.i

内存管理基类，包括：

1、动态内存分配基类（ACE_New_Allocator/ACE_Allocator），定义了系统动态内存分配相关操作。

2、静态线性内存分配基类（ACE_Static_Allocator_Base)，初始静态分配一段内存，应用申请内存时从中移位获取，并且申请后不再释放。

Malloc_T.cpp

Malloc_T.h

Malloc_T.i

内存管理类，包括：

1、对象内存分配类（ACE_Cached_Allocator），一个以free list类结构为基础构造的内存分配类，每次从链表中取出或返还一个内存块。

2、线性内存分配类（ACE_Malloc），以环形链表为数据结构，每个节点包含一个内存块，每次从链表中取出或返回内存块；并且可以把一个名称绑定到一个地址上，形成一个名称链表，通过名称来查找地址；还有一个迭代器用来索引名称链表。

Memory_Pool.cpp

Memory_Pool.h

Memory_Pool.i

内存池管理类，包括：

1、本地内存池类（ACE_Local_Memory_Pool），使用系统动态内存接口来申请内存。

2、共享内存池类（ACE_MMAP_Memory_Pool），使用共享内存机制来申请内存。

3、System_V风格共享内存池类（ACE_Shared_Memory_Pool），使用System_V共享内存机制来申请内存，略过。

[Memory/Shared_Memory]

　

Shared_Memory.cpp

Shared_Memory.h

共享内存外覆基类(ACE_Shared_Memory)，在ACE_Mem_Map基础上封装了一层。

Shared_Memory_MM.cpp

Shared_Memory_MM.h

Shared_Memory_MM.i

共享内存外覆类（ACE_Shared_Memory_MM），在ACE_Mem_Map基础上封装了一层。

Shared_Memory_SV.cpp

Shared_Memory_SV.h

Shared_Memory_SV.i

System_V风格共享内存类（ACE_Shared_Memory_SV），略过。

[Memory/Utils]

　

Obstack.cpp

Obstack.h

Obstack.i

内存管理类（ACE_Obstack），分配和管理包含头信息（ACE_Obchunk）的内存块，并以链表形式来组织内存块。

Read_Buffer.cpp

Read_Buffer.h

Read_Buffer.i

流读取类（ACE_Read_Buffer），从流中读取一段数据，并把搜索到的字符替换成替换字符。

[Misc]

　

ARGV.cpp

ARGV.h

ARGV.i

参数类，参数有字符串、数组、队列三种存储格式，并完成之间的相互转换。

Auto_Ptr.cpp

Auto_Ptr.h

Auto_Ptr.i

智能指针类。

Date_Time.cpp

Date_Time.h

Date_Time.i

日期时间类。

Dynamic.cpp

Dynamic.h

Dynamic.i

对象动态分配标志类，在一个类的new操作符函数里置位动态分配标志，然后在这个类的构造函数里检查这个标志位并保存，后面在这个类的destory函数里根据标志来决定是否释放对象。

便于当某个对象被其他对象管理，而管理对象统一通过destory接口释放这个对象时，能够根据这个对象是动态分配对象，还是全局对象进行不同的释放操作。

Get_Opt.cpp

Get_Opt.h

Get_Opt.i

入参解析类，完成C库函数getopts相类似的功能。
ACE_Get_Opt::operator ()处理逻辑有问题。

Registry.cpp

Registry.h

注册表管理类，能够对注册表内键和项两种结构进行相关操作，还定义了一个迭代器可以对管理类进行遍历操作，生成键和项两种类型节点的列表，迭代器内还包含独立的键迭代器和项迭代器。

Singleton.cpp

Singleton.h

Singleton.i

单件类，提供静态实例化函数在第一次被调用动态创建对象，并且注册到对象管理类，使得对象管理类能负责它的释放。

System_Time.cpp

System_Time.h

时间类，能够获取本地时间或者系统时间。

[Name_Service]

　

Local_Name_Space.cpp

Local_Name_Space.h

名字和名字值类型类，定义了名字和值类型对象封装类，以及与字符串对象的相互转换操作，用于映射。

Local_Name_Space_T.cpp

Local_Name_Space_T.h

名字空间映射类，基于哈希表关联数组类的数据结构，关联的对象是名字类以及名字值类型类，同时包含了对数据结构的相关操作。

本地名字空间类，创建一个本地数据库以及对应的名字空间映射对象，两者之间的同步机制没有实现，然后能够基于这个名字空间映射对象进行名字、名字值、名字类型相互之间的绑定、解绑定、查找等操作。

Name_Proxy.cpp

Name_Proxy.h

名字服务代理类，完成与对端服务器的名字请求与响应交互动作，用于远端名字服务的客户端。

Name_Request_Reply.cpp

Name_Request_Reply.h

名字请求、响应类，定义了客户端和名字服务器间交互的请求和响应对象结构，以及相应的编解码等操作。

Name_Space.cpp

Name_Space.h

名字空间基类，定义了名字、值、类型三者之间的对应关系集，以及针对这个集的绑定、解绑定、获取等操作接口，没有定义实际数据成员。

Naming_Context.cpp

Naming_Context.h

名字空间上下文服务类，作为服务对象，能够独立完成入参解析，并根据名字空间类型：本进程、本机、远程，分别把名字空间相关操作委托给实际的名字空间派生类处理，用于给用户提供名字服务。

Registry_Name_Space.cpp

Registry_Name_Space.h

注册表名字空间类，采用注册表来存储名字和名字值，然后完成名字、名字值、名字类型相互之间的绑定、解绑定、查找等操作。

Remote_Name_Space.cpp

Remote_Name_Space.h

远端名字空间类，调用名字服务代理类，构造请求发向远端名字服务器，接受响应并解析，来完成名字、名字值、名字类型相互之间的绑定、解绑定、查找等操作。

[OS Adapters]

　

ACE.cpp

ACE.h

ACE.i

包含了一些操作系统API的接口封装。

OS.cpp

OS.h

OS.i

包含了各ACE类中需要调用操作系统API的函数的实现，以及一些操作系统API的接口封装。

[Reactor]

　

Event_Handler.cpp

Event_Handler.h

Event_Handler.i

事件基类，定义了各类事件处理的基类接口。

Event_Handler_T.cpp

Event_Handler_T.h

Event_Handler_T.i

事件模板类，定义了各类事件处理的接口以及将处理委托到模板对象上。

Handle_Set.cpp

Handle_Set.h

Handle_Set.i

描述符集类，封装了socket操作的描述符集对象的相关操作。

描述符集迭代器类，能够在描述符集里访问被置位了的描述符。

Priority_Reactor.cpp

Priority_Reactor.i

Priority_Reactor.h

优先级反应器类，相对于select反应器，采用优先级队列来存储分派的事件，当事件分派时，根据事件的优先级入队到相应优先级队列中，再对各优先级队列中的所有事件进行出队分派处理。

Proactor.cpp

Proactor.h

Proactor.i

前摄器类，1、定时器通过schedule_timer创建加入定时器队列，构造函数启动独立线程在函数svc中来轮询等待定时器队列中定时器超时，定时器超时处理函数timeout将超时处理消息发给完成端口，前摄器事件处理函数handle_events等待完成端口中的事件，进而执行特定的完成处理。2、当向前摄器注册一个IO句柄时，把这个句柄关联到完成端口，从而对这个句柄的IO异步操作立即返回，同时前摄器事件处理函数handle_events等待完成端口中的事件，进而执行相应的IO异步操作完成处理动作。

Reactor.cpp

Reactor.h

Reactor.i

反应器封装类，封装了单件反应器对象，并把反应相关接口委托到实际的基于不同算法的反应器对象上。

Reactor_Impl.h

　

Select_Reactor.cpp

Select_Reactor.h

Select_Reactor.i

基于select的反应器类，多线程轮询并分派事件处理，但是一个时刻只能有一个线程处于轮询处理状态，其他线程要能进行轮询处理需要使用owner()方法设置所有者线程。

反应器同步类（ACE_Select_Reactor_Token），负责当其他线程调用反应器接口时，为了保证对反应器共享数据的同步访问，先通过sleep_hook接口给反应器主线程发一个通知消息，让反应器主线程暂时让出锁，从而得到执行的机会，反应器主线程在让出锁的同时，把自己放入token的队列并等待锁，使得其他线程完成处理后能够再拿到锁继续执行。

反应器事件通知类（ACE_Select_Reactor_Notify），封装了反应器的事件通知处理机制，底层通过管道来实现，包括通知事件的写入管道和在反应器主循环轮询去读这个管道，拿到事件后的分配处理。

反应器事件管理类（ACE_Select_Reactor_Handler_Repository），负责管理事件句柄和事件处理类之间的映射关系，以及相关的查询、绑定、解绑定等操作。

反应器类（ACE_Select_Reactor），包含主循环会轮询和分派处理各种事件，包括处理定时器超时事件，通知事件，以及IO端口消息事件。当分派处理IO端口事件时，调用用户的处理函数处理，如果返回值大于0，则把事件保存在ready_set，这样循环下次运行时可以不用经过select操作再次分派处理。

WFMO_Reactor.cpp

WFMO_Reactor.h

WFMO_Reactor.i

基于Win32 WaitForMultipleObjects的反应器类，多个线程同时轮询并分派处理事件，反应器本身不提供事件分派处理的同步，需要业务应用来提供自己的同步机制。

反应器事件管理类（ACE_WFMO_Reactor_Handler_Repository），负责管理事件句柄和事件处理类之间的映射关系，以及相关的绑定、解绑定、挂起、恢复等操作，同时因为多线程并发，所以对于这些事件操作改变不立即生效，而是分队列存储，等待反应器在合适时机来将改变生效。

反应器事件通知类（ACE_WFMO_Reactor_Notify），负责为反应器定时器提供实现机制，通过把自身注册到反应器的监测事件队列中去，定时器启动时把超时处理打包成消息入自身队列，同时给出信号，反应器收到信号后调用通知类处理函数，处理函数从自身队列拿出消息，触发事件超时处理。

反应器类（ACE_WFMO_Reactor），将同步事件、通知事件、已被注册的事件列表注册到监听队列，可以触发多个线程在各自的事件处理函数中各自监测各类事件，并根据事件不同类型进行相应的分派，分派完成后，由一个主线程对分派过程中监测队列中的改变进行处理生效，其他线程略过。

Msg_WFMO_Reactor.cpp

Msg_WFMO_Reactor.h

Msg_WFMO_Reactor.i

增强型反应器类，相对于WFMO反应器，能够对Windows消息进行探测，以及进行相应的翻译分发处理。

XtReactor.cpp

XtReactor.h

X工具库反应器类，相对于select反应器做了如下改变：

1、事件等待采用XtAppProcessEvent。

2、定时器操作时通过XtAppAddTimeOut附加上了自己的一套处理函数。

3、增加监测事件时，通过XtAppAddInput增加了一套快速监测并发派处理的机制。

[Service_Configurator]

　

Parse_Node.cpp

Parse_Node.h

Parse_Node.i

解析节点类，定义了服务配置文件解析后一个个基本节点对象的组织结构。

挂起节点类，定义了服务配置文件挂起操作解析出来的节点对应的动作。

恢复节点类，定义了服务配置文件恢复操作解析出来的节点对应的动作。

删除节点类，定义了服务配置文件删除操作解析出来的节点对应的动作。

静态节点类，定义了服务配置文件解析出来的静态节点（服务被静态链接到应用程序）对应的动作。

动态节点类，定义了服务配置文件解析出来的动态节点（服务被动态态链接到应用程序）对应的动作。

流节点类，定义了服务配置文件解析出来的流节点对应的动作。

动态库定位类，定义开启动态库加载后的操作句柄动作。

动态库对象类，定义动态库中动态对象符号地址的获取动作。

动态库函数类，定义动态库中动态函数符号地址的获取动作，以及调用函数返回节点对象。

哑节点类，定义了一个空的节点对应的动作。

静态函数类，定义静态函数地址的获取，以及调用函数返回节点对象。

Service_Config.cpp

Service_Config.h

Service_Config.i

服务配置类，能够a、根据静态对象列表创建静态对象。b、对配置文件进行解析，并根据解析结果创建相应的动态对象。并把生成的服务对象插入服务容器类进行后续管理，比如挂起、恢复、销毁等操作。

Service_Manager.cpp

Service_Manager.h

Service_Manager.i

服务管理类，向反应器注册一个监听事件，当有客户端连接上时执行相应的操作，并把操作的结果通过socket发回给客户端，操作包括：显示目前运行的服务信息、重新根据配置文件启动服务等。

Service_Object.cpp

Service_Object.h

Service_Object.i

服务对象抽像基类，定义了服务对象的挂起、恢复操作接口。

服务外覆类，对服务进行了封装，并定义了相应的对外接口，具体处理委托到具体的服务类完成。

服务对象智能指针类，定义了包含服务对象的智能指针类。

Service_Repository.cpp

Service_Repository.h

Service_Repository.i

服务容器类，包含了一个服务外覆类的容器，并且支持对这个容器的查找、插入、删除、挂起、恢复等操作。

服务容器类迭代器，能够对服务类型容器类进行迭代操作。

Service_Types.cpp

Service_Types.i

Service_Types.h

服务抽象基类，定义了服务的初始化、去初始化、挂起、恢复、查询等操作，以及对三种服务对象的引用。

Service_Object服务类，定义了对Service_Object对象的服务封装。

Module服务类，定义了对Module对象的服务封装。

Stream服务类，定义了对Stream对象的服务封装。

Shared_Object.cpp

Shared_Object.h

Shared_Object.i

共享对象抽象基类，定义了共享对象的基本操作接口。

Svc_Conf.h

　

Svc_Conf_l.cpp

通过flex产生的扫描器，略过。

Svc_Conf_y.cpp

通过yacc产生的扫描器，略过。

Svc_Conf_Tokens.h

　

[Streams]

　

IO_Cntl_Msg.cpp

IO_Cntl_Msg.h

IO_Cntl_Msg.i

IO控制消息类，封装了IO控制消息相关的类型、值等信息。

Message_Block.cpp

Message_Block.h

Message_Block.i

数据块类，负责数据buffer的管理，包括分配、释放、克隆等。

消息块类，采用数据库类作为节点，形成一个链表，每个节点还可以另外挂载一个消息块链表，并且增加了读写标志、优先级等信息便于实际使用。

Message_Queue.cpp

Message_Queue.h

Message_Queue.i

消息队列类，对消息块链表进行管理，实现包括入队、出队等操作。

消息队列正向、反向迭代器，能够对消息队列进行正向、反向的遍历操作。

Module.cpp

Module.h

Module.i

模块类，包含了两个任务，并对这两个任务进行管理，这两个任务分别进行流的读写工作。

Multiplexor.cpp

Multiplexor.h

Multiplexor.i

空文件。

Stream.cpp

Stream.h

Stream.i

流类，一个流包含头模块和一个尾模块，头模块和尾模块都分别由两个流头类和两个流尾类构成，头尾模块之间是一个个处理模块，每个模块都包含两个任务。同时定义了流构建、销毁、插入模块、删除模块、推送消息块、获取消息块、发送控制消息、链接两个流、去链接两个流等操作。

Stream_Modules.cpp

Stream_Modules.h

Stream_Modules.i

流头类和流尾类，分别定义了消息块入流头和入流尾操作，都各自对应一个任务。

Task.cpp

Task.h

Task.i

任务基类，定义了一个任务的概念，可以包含多个线程，以及任务的创建、挂起、恢复、销毁等生命周期操作。

Task_T.cpp

Task_T.h

Task_T.i

任务模板类，在任务基类的基础上包含了消息队列对象，以及对消息队列的相关操作。

[System_V_IPC]

System_V风格的IPC，整体略过。

[System_V_IPC/System_V_Message_Queues]

　

SV_Message.cpp

SV_Message.h

SV_Message.i

　

SV_Message_Queue.cpp

SV_Message_Queue.h

SV_Message_Queue.i

　

Typed_SV_Message.cpp

Typed_SV_Message.h

Typed_SV_Message.i

　

Typed_SV_Message_Queue.cpp

Typed_SV_Message_Queue.h

Typed_SV_Message_Queue.i

　

[System_V_IPC/System_V_Semaphores]

　

SV_Semaphore_Complex.cpp

SV_Semaphore_Complex.h

SV_Semaphore_Complex.i

　

SV_Semaphore_Simple.cpp

SV_Semaphore_Simple.h

SV_Semaphore_Simple.i

　

[System_V_IPC/System_V_Shared_Memory]

　

SV_Shared_Memory.cpp

SV_Shared_Memory.h

SV_Shared_Memory.i

　

[Timers]

　

High_Res_Timer.cpp

High_Res_Timer.h

High_Res_Timer.i

高精度时间类，支持到纳秒级别，包含纳秒时间获取、相关的计时、与其他时间格式转换等操作。

Profile_Timer.cpp

Profile_Timer.h

Profile_Timer.i

UINX时间类，支持UNIX内部时间格式的获取、计时等操作。

Time_Request_Reply.cpp

Time_Request_Reply.h

时间请求类，封装了向时间服务器发起请求的消息对象，包括消息对象的构造、销毁、编解码等操作。

Timer_Hash.cpp

Timer_Hash.h

哈希定时器队列类，模板类的实例化。

Timer_Hash_T.cpp

Timer_Hash_T.h

哈希定时器队列模板类，内部包含一个哈希数组，数组的每个元素是一个ACE_Timer_Queue_T派生类对象，启动定时器时，入队也是根据超时时间除以哈希数组大小求余得到定时器要放在哈希数组中的位置，再把分配定时器对象以及入队操作委托给这个位置的ACE_Timer_Queue_T派生类对象处理。

Timer_Heap.cpp

Timer_Heap.h

预分配定时器队列类，模板类的实例化。

Timer_Heap_T.cpp

Timer_Heap_T.h

预分配定时器队列模板类，不使用freelist的定时器对象分配管理机制，支持预分配一组定时器对象，并放在内部可用定时器队列进行分配管理。

启动定时器时，从可用定时器队列中获取定时器对象，然后再从定时器句柄数组中获取可用的句柄，再按照部分有序的算法把定时器对象放到一个已分配定时器数组中进行管理，定时器句柄数组里存储着定时器句柄对应的定时器对象在已分配定时器数组中的位置。

取消定时器时，把定时器对象还给可用定时器队列，定时器句柄也还给定时器句柄数组，在根据定时器句柄找到定时器对象在已分配定时器数组中的位置，然后把定时器对象从已分配定时器数组中删除。

Timer_List.cpp

Timer_List.h

链表定时器队列类，模板类的实例化。

Timer_List_T.cpp

Timer_List_T.h

链表定时器队列模板类，内部使用环形链表来存储已分配的定时器，且保持链表内根据超时时间递增排序，定时器对象从freelist获取。

Timer_Queue.cpp

Timer_Queue.h

Timer_Queue.i

定时器队列类，模板类的实例化。

Timer_Queue_Adapters.cpp

Timer_Queue_Adapters.h

Timer_Queue_Adapters.i

基于alarm的定时器队列类，创建定时器时同时启动alarm定时器，在定时器超时信号处理函数里调用定时器队列的超时处理

线程定时器队列类，采用一个或多个线程来等待处理定时器队列的超时处理。

这两个适配器类还比较雏形，有缺陷。

Timer_Queue_T.cpp

Timer_Queue_T.h

Timer_Queue_T.i

定时器队列模板类，包含一组定时器，能够定时器的启动、停止、超时处理等动作。

Timer_Wheel.cpp

Timer_Wheel.h

时间轮定时器队列类，模板类的实例化。

Timer_Wheel_T.cpp

Timer_Wheel_T.h

时间轮定时器队列模板类，内部对于定时器存储方式为一个哈希数组，每个数组指向一个循环链表，链表每个节点是一个定时器对象，链表内根据定时器超时时间保持递增排序，但哈希数组各个成员之间没有排序关系，定时器对象从freelist获取。启动定时器时，入队列根据超时时间除以哈希数组大小求余到定时器要放在哈希数组中的位置。

[Token_Service]

　

Local_Tokens.cpp

Local_Tokens.h

Local_Tokens.i

令牌代理实体类（ACE_TPQ_Entry），指向一个令牌代理对象，并实现在一个令牌代理队列中的相关操作。

令牌代理队列类（ACE_Token_Proxy_Queue），维护令牌的持有者队列，以及相关队列操作。

令牌类（ACE_Tokens），定义了一个令牌对象相关操作接口，并维护有一个令牌持有者队列。

互斥锁令牌类（ACE_Mutex_Token），定义了一个互斥锁类型的令牌对象的具体操作。

读写锁令牌类（ACE_RW_Token），定义了一个读写锁类型的令牌对象的具体操作。

令牌代理类（ACE_Token_Proxy），指向实际的令牌对象，可以挂载不同类型的令牌类，完成用户对令牌的各种获取、释放等操作。

令牌的获取和释放等操作为什么要把另外一个令牌对象作为入参没看明白。

Remote_Tokens.cpp

Remote_Tokens.h

Remote_Tokens.i

远程令牌代理类，通过一个socket连接，向远程发送请求和接收响应来完成令牌的相关获取、释放等操作。

Token_Collection.cpp

Token_Collection.h

Token_Collection.i

令牌集类，定了包含一组令牌的对象，并能对他们进行整体的或者个别的令牌获取、释放等操作。

Token_Manager.cpp

Token_Manager.h

Token_Manager.i

令牌管理类，负责管理令牌的分配、释放、死锁检测等动作，是单件类。

Token_Request_Reply.cpp

Token_Request_Reply.h

Token_Request_Reply.i

令牌请求类，定义了客户端发向服务器的令牌请求结构及相关操作。

令牌响应类，定义了客户端发向服务器的令牌响应结构及相关操作。

Token_Invariants.cpp

Token_Invariants.h

Token_Invariants.i

互斥锁和读写锁令牌类，同时包含互斥锁和读写锁，并在令牌的获取、释放等操作时能根据锁的不同做区分处理。

 

（完）