利用ACL开发并发网络服务器

1、概述
    本节结合 "利用ACL库开发高并发半驻留式线程池程序" 和 "利用ACL库快速创建你的网络程序" 两篇文章的内容，创建一个简单的线程池网络服务器程序。
2、并发式网络通信实例

1. #include "lib_acl.h"  /* 先包含ACL库头文件 */
2. #include <stdio.h>
3. #include <stdlib.h>
4.  
5. /**
6.  * 单独的线程处理来自于客户端的连接
7.  * @param arg {void*} 添加任务时的对象
8.  */
9. static void echo_client_thread(void *arg)
10. {
11.     ACL_VSTREAM *client = (ACL_VSTREAM*) arg;
12.     char  buf[1024];
13.     int   n;
14.  
15.     /* 设置客户端流的读超时时间为30秒 */
16.     ACL_VSTREAM_SET_RWTIMO(client, 30);
17.  
18.     /* 循环读客户端的数据，直到其关闭或出错或超时 */
19.     while (1) {
20.         /* 等待读客户端发来的数据 */
21.         n = acl_vstream_read(client, buf, sizeof(buf));
22.         if (n == ACL_VSTREAM_EOF)
23.             break;
24.         /* 将读到的数据写回至客户端流 */
25.         if (acl_vstream_writen(client, buf, n) == ACL_VSTREAM_EOF)
26.             break;
27.     }
28.  
29.     /* 关闭客户端流 */
30.     acl_vstream_close(client);
31. }
32.  
33. /**
34.  * 创建半驻留线程池的过程
35.  * @return {acl_pthread_pool_t*} 新创建的线程池句柄
36.  */
37. static acl_pthread_pool_t *create_thread_pool(void)
38. {
39.     acl_pthread_pool_t *thr_pool;  /* 线程池句柄 */
40.     int  max_threads = 100;  /* 最多并发100个线程 */
41.     int  idle_timeout = 10;  /* 每个工作线程空闲10秒后自动退出 */
42.     acl_pthread_pool_attr_t attr;  /* 线程池初始化时的属性 */
43.  
44.     /* 初始化线程池对象属性 */
45.     acl_pthread_pool_attr_init(&attr);
46.     acl_pthread_pool_attr_set_threads_limit(&attr, max_threads);
47.     acl_pthread_pool_attr_set_idle_timeout(&attr, idle_timeout);
48.  
49.     /* 创建半驻留线程句柄 */
50.     thr_pool = acl_pthread_pool_create(&attr);
51.     assert(thr_pool);
52.     return (thr_pool);
53. }
54.  
55. /**
56.  * 开始运行
57.  * @param addr {const char*} 服务器监听地址，如：127.0.0.1:8081
58.  */
59. static void run(const char *addr)
60. {
61.     const char *myname = "run";
62.     acl_pthread_pool_t *thr_pool;
63.     ACL_VSTREAM *sstream;
64.     char  ebuf[256];
65.  
66.     thr_pool = create_thread_pool();
67.  
68.     /* 监听一个本地地址 */
69.     sstream = acl_vstream_listen(addr, 128);
70.     if (sstream == NULL) {
71.         printf("%s(%d): listen on %s error(%s)/r/n",
72.             myname, __LINE__, addr,
73.             acl_last_strerror(ebuf, sizeof(ebuf)));
74.         return;
75.     }
76.  
77.     printf("%s: listen %s ok/r/n", myname, addr);
78.     while (1) {
79.         /* 等待接受客户端的连接 */
80.         client = acl_vstream_accept(sstream, NULL, 0);
81.         if (client == NULL) {
82.             printf("%s(%d): accept error(%s)/r/n",
83.                 myname, __LINE__,
84.                 acl_last_strerror(ebuf, sizeof(ebuf)));
85.             break;
86.         }
87.         printf("accept one/r/n");
88.         /* 获得一个客户端连接流 */
89.         /* 开始处理该客户端连接流 */
90.  
91.         /**
92.          * 向线程池中添加一个任务
93.          * @param thr_pool 线程池句柄
94.          * @param echo_client_thread 工作线程的回调函数
95.          * @param client 客户端数据流
96.          */
97.         acl_pthread_pool_add(thr_pool, echo_client_thread, client);
98.     }
99.  
100.     /* 销毁线程池对象 */
101.     acl_pthread_pool_destroy(thr_pool);
102. }
103.  
104. /**
105.  * 初始化过程
106.  */
107. static void init(void)
108. {
109.     /* 初始化ACL库 */
110.     acl_init();
111. }
112.  
113. /**
114.  * 使用提示接口
115.  * @param procname {cosnt char*} 程序名
116.  */
117. static void usage(const char *procname)
118. {
119.     printf("usage: %s listen_addr/r/n", procname);
120.     printf("example: %s 127.0.0.1:8081/r/n", procname);
121.     getchr();   
122. }
123.  
124. int main(int argc, char *argv[])
125. {
126.     if (argc != 2) {
127.         usage(argv[0]);
128.         return (0);
129.     }
130.  
131.     init();
132.     run(argv[1]);
133.     return (0);
134. }

    由上可以看出，创建一个并发式服务器程序也是如此的简单。 该例子可以同时运行在WIN32平台及UNIX平台（Linux, FreeBSD, Solaris-x86).

3、小结
    由以上例子可以看出，ACL库屏蔽底层SOCKET的细节操作，使网络编程变得简单，使使用者可以专心于其应用，而不是拘泥于SOCKET操作上，另外结合半驻留线程池的ACL库就可以开发高效的并发网络应用来。
　　当然，以上例子也存在一个缺点，那就是当客户端并发连接比较高时，因为一个连接占用一个线程，所以高并发时就需要更多的线程（为了启动更多的线程，可以通过 acl_pthread_pool_set_stacksize 或 acl_pthread_pool_attr_set_stacksize 设置每个线程的堆栈为较小的值，如 500KB）；而采用ACL库里的另一种编程技术－－非阻塞式IO，可以使一个线程同时处理多个并发TCP连接，同时可以启动多个这样的非阻塞线程，从而可以更好地利用多核（一般是一个核可以启用一个非阻塞IO线程），将来，我们将会对此类问题进行讨论，并给出具体实例。

   acl 库的下载地址：http://www.sourceforge.net/projects/acl/
   acl 库的在线帮助地址：http://acl.sourceforge.net/acl_help/index.html