libuv网络库的TCP服务端与客户端

本人一直在寻找一个跨平台的网络库，boost与ACE比较庞大，不考虑。对比了libevent,libev,libuv后，最终选择了libuv.可libuv文档少，例子也简单，对于tcp只有个echo-server的例子。网上也找过对其封装的例子，如下

libsourcey库，封装了许多库。对libuv的封装跟其他代码耦合比较紧，难为剥离 http://sourcey.com/libuv-cpp-wrappers/
C++11封装的，可惜VS10未完全支持C++11 https://github.com/larroy/uvpp
C++封装的  https://github.com/keepallsimple/uvpp

       本人想实现一个raw tcp server,支持上万链接数的，网上找到的都没合适我的，没办法只能参照各例子自己封装了

[cpp]  view plain copy

1. /*************************************** 
2. * @file     tcpsocket.h 
3. * @brief    基于libuv封装的tcp服务器与客户端,使用log4z作日志工具 
4. * @details 
5. * @author   陈吉宏, wqvbjhc@gmail.com 
6. * @date     2014-5-13 
7. * @mod      2014-5-13  phata  修正服务器与客户端的错误.现服务器支持多客户端连接 
8.                               修改客户端测试代码，支持并发多客户端测试 
9. ****************************************/  
10. #ifndef TCPSocket_H  
11. #define TCPSocket_H  
12. #include "uv.h"  
13. #include <string>  
14. #include <list>  
15. #include <map>  
16. #define BUFFERSIZE (1024*1024)  
17.   
18. namespace uv  
19. {  
20. typedef void (*newconnect)(int clientid);  
21. typedef void (*server_recvcb)(int cliendid, const char* buf, int bufsize);  
22. typedef void (*client_recvcb)(const char* buf, int bufsize, void* userdata);  
23.   
24. class TCPServer;  
25. class clientdata  
26. {  
27. public:  
28.     clientdata(int clientid):client_id(clientid),recvcb_(nullptr) {  
29.         client_handle = (uv_tcp_t*)malloc(sizeof(*client_handle));  
30.         client_handle->data = this;  
31.         readbuffer = uv_buf_init((char*)malloc(BUFFERSIZE), BUFFERSIZE);  
32.         writebuffer = uv_buf_init((char*)malloc(BUFFERSIZE), BUFFERSIZE);  
33.     }  
34.     virtual ~clientdata() {  
35.         free(readbuffer.base);  
36.         readbuffer.base = nullptr;  
37.         readbuffer.len = 0;  
38.   
39.         free(writebuffer.base);  
40.         writebuffer.base = nullptr;  
41.         writebuffer.len = 0;  
42.   
43.         free(client_handle);  
44.         client_handle = nullptr;  
45.     }  
46.     int client_id;//客户端id,惟一  
47.     uv_tcp_t* client_handle;//客户端句柄  
48.     TCPServer* tcp_server;//服务器句柄(保存是因为某些回调函数需要到)  
49.     uv_buf_t readbuffer;//接受数据的buf  
50.     uv_buf_t writebuffer;//写数据的buf  
51.     uv_write_t write_req;  
52.     server_recvcb recvcb_;//接收数据回调给用户的函数  
53. };  
54.   
55.   
56. class TCPServer  
57. {  
58. public:  
59.     TCPServer(uv_loop_t* loop = uv_default_loop());  
60.     virtual ~TCPServer();  
61.     static void StartLog(const char* logpath = nullptr);//启动日志，必须启动才会生成日志  
62. public:  
63.     //基本函数  
64.     bool Start(const char *ip, int port);//启动服务器,地址为IP4  
65.     bool Start6(const char *ip, int port);//启动服务器，地址为IP6  
66.     void close();  
67.   
68.     bool setNoDelay(bool enable);  
69.     bool setKeepAlive(int enable, unsigned int delay);  
70.   
71.     const char* GetLastErrMsg() const {  
72.         return errmsg_.c_str();  
73.     };  
74.   
75.     virtual int  send(int clientid, const char* data, std::size_t len);  
76.     virtual void setnewconnectcb(newconnect cb);  
77.     virtual void setrecvcb(int clientid,server_recvcb cb);//设置接收回调函数，每个客户端各有一个  
78. protected:  
79.     int GetAvailaClientID()const;//获取可用的client id  
80.     bool DeleteClient(int clientid);//删除链表中的客户端  
81.     //静态回调函数  
82.     static void AfterServerRecv(uv_stream_t *client, ssize_t nread, const uv_buf_t* buf);  
83.     static void AfterSend(uv_write_t *req, int status);  
84.     static void onAllocBuffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);  
85.     static void AfterServerClose(uv_handle_t *handle);  
86.     static void AfterClientClose(uv_handle_t *handle);  
87.     static void acceptConnection(uv_stream_t *server, int status);  
88.   
89. private:  
90.     bool init();  
91.     bool run(int status = UV_RUN_DEFAULT);  
92.     bool bind(const char* ip, int port);  
93.     bool bind6(const char* ip, int port);  
94.     bool listen(int backlog = 1024);  
95.   
96.   
97.     uv_tcp_t server_;//服务器链接  
98.     std::map<int,clientdata*> clients_list_;//子客户端链接  
99.     uv_mutex_t mutex_handle_;//保护clients_list_  
100.     uv_loop_t *loop_;  
101.     std::string errmsg_;  
102.     newconnect newconcb_;  
103.     bool isinit_;//是否已初始化，用于close函数中判断  
104. };  
105.   
106.   
107.   
108. class TCPClient  
109. {  
110.     //直接调用connect/connect6会进行连接  
111. public:  
112.     TCPClient(uv_loop_t* loop = uv_default_loop());  
113.     virtual ~TCPClient();  
114.     static void StartLog(const char* logpath = nullptr);//启动日志，必须启动才会生成日志  
115. public:  
116.     //基本函数  
117.     virtual bool connect(const char* ip, int port);//启动connect线程，循环等待直到connect完成  
118.     virtual bool connect6(const char* ip, int port);//启动connect线程，循环等待直到connect完成  
119.     virtual int  send(const char* data, std::size_t len);  
120.     virtual void setrecvcb(client_recvcb cb, void* userdata);////设置接收回调函数，只有一个  
121.     void close();  
122.   
123.     //是否启用Nagle算法  
124.     bool setNoDelay(bool enable);  
125.     bool setKeepAlive(int enable, unsigned int delay);  
126.   
127.     const char* GetLastErrMsg() const {  
128.         return errmsg_.c_str();  
129.     };  
130. protected:  
131.     //静态回调函数  
132.     static void AfterConnect(uv_connect_t* handle, int status);  
133.     static void AfterClientRecv(uv_stream_t *client, ssize_t nread, const uv_buf_t* buf);  
134.     static void AfterSend(uv_write_t *req, int status);  
135.     static void onAllocBuffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);  
136.     static void AfterClose(uv_handle_t *handle);  
137.   
138.     static void ConnectThread(void* arg);//真正的connect线程  
139.     static void ConnectThread6(void* arg);//真正的connect线程  
140.   
141.     bool init();  
142.     bool run(int status = UV_RUN_DEFAULT);  
143. private:  
144.     enum {  
145.         CONNECT_TIMEOUT,  
146.         CONNECT_FINISH,  
147.         CONNECT_ERROR,  
148.         CONNECT_DIS,  
149.     };  
150.     uv_tcp_t client_;//客户端连接  
151.     uv_loop_t *loop_;  
152.     uv_write_t write_req_;//写时请求  
153.     uv_connect_t connect_req_;//连接时请求  
154.     uv_thread_t connect_threadhanlde_;//线程句柄  
155.     std::string errmsg_;//错误信息  
156.     uv_buf_t readbuffer_;//接受数据的buf  
157.     uv_buf_t writebuffer_;//写数据的buf  
158.     uv_mutex_t write_mutex_handle_;//保护write,保存前一write完成才进行下一write  
159.   
160.     int connectstatus_;//连接状态  
161.     client_recvcb recvcb_;//回调函数  
162.     void* userdata_;//回调函数的用户数据  
163.     std::string connectip_;//连接的服务器IP  
164.     int connectport_;//连接的服务器端口号  
165.     bool isinit_;//是否已初始化，用于close函数中判断  
166. };  
167.   
168. }  
169.   
170.   
171. #endif // TCPSocket_H  

[cpp]  view plain copy

1. #include "tcpsocket.h"  
2. #include "log4z.h"  
3.   
4. std::string GetUVError(int retcode)  
5. {  
6.     std::string err;  
7.     err = uv_err_name(retcode);  
8.     err +=":";  
9.     err += uv_strerror(retcode);  
10.     return std::move(err);  
11. }  
12.   
13. namespace uv  
14. {  
15. /*****************************************TCP Server*************************************************************/  
16. TCPServer::TCPServer(uv_loop_t* loop)  
17.     :newconcb_(nullptr), isinit_(false)  
18. {  
19.     loop_ = loop;  
20. }  
21.   
22.   
23. TCPServer::~TCPServer()  
24. {  
25.     close();  
26.     LOGI("tcp server exit.");  
27. }  
28.   
29. //初始化与关闭--服务器与客户端一致  
30. bool TCPServer::init()  
31. {  
32.     if (isinit_) {  
33.         return true;  
34.     }  
35.   
36.     if (!loop_) {  
37.         errmsg_ = "loop is null on tcp init.";  
38.         LOGE(errmsg_);  
39.         return false;  
40.     }  
41.     int iret = uv_mutex_init(&mutex_handle_);  
42.     if (iret) {  
43.         errmsg_ = GetUVError(iret);  
44.         LOGE(errmsg_);  
45.         return false;  
46.     }  
47.     iret = uv_tcp_init(loop_,&server_);  
48.     if (iret) {  
49.         errmsg_ = GetUVError(iret);  
50.         LOGE(errmsg_);  
51.         return false;  
52.     }  
53.     isinit_ = true;  
54.     server_.data = this;  
55.     //iret = uv_tcp_keepalive(&server_, 1, 60);//调用此函数后后续函数会调用出错  
56.     //if (iret) {  
57.     //  errmsg_ = GetUVError(iret);  
58.     //  return false;  
59.     //}  
60.     return true;  
61. }  
62.   
63. void TCPServer::close()  
64. {  
65.     for (auto it = clients_list_.begin(); it!=clients_list_.end(); ++it) {  
66.         auto data = it->second;  
67.         uv_close((uv_handle_t*)data->client_handle,AfterClientClose);  
68.     }  
69.     clients_list_.clear();  
70.   
71.     LOGI("close server");  
72.     if (isinit_) {  
73.         uv_close((uv_handle_t*) &server_, AfterServerClose);  
74.         LOGI("close server");  
75.     }  
76.     isinit_ = false;  
77.     uv_mutex_destroy(&mutex_handle_);  
78. }  
79.   
80. bool TCPServer::run(int status)  
81. {  
82.     LOGI("server runing.");  
83.     int iret = uv_run(loop_,(uv_run_mode)status);  
84.     if (iret) {  
85.         errmsg_ = GetUVError(iret);  
86.         LOGE(errmsg_);  
87.         return false;  
88.     }  
89.     return true;  
90. }  
91. //属性设置--服务器与客户端一致  
92. bool TCPServer::setNoDelay(bool enable)  
93. {  
94.     int iret = uv_tcp_nodelay(&server_, enable ? 1 : 0);  
95.     if (iret) {  
96.         errmsg_ = GetUVError(iret);  
97.         LOGE(errmsg_);  
98.         return false;  
99.     }  
100.     return true;  
101. }  
102.   
103. bool TCPServer::setKeepAlive(int enable, unsigned int delay)  
104. {  
105.     int iret = uv_tcp_keepalive(&server_, enable , delay);  
106.     if (iret) {  
107.         errmsg_ = GetUVError(iret);  
108.         LOGE(errmsg_);  
109.         return false;  
110.     }  
111.     return true;  
112. }  
113.   
114. //作为server时的函数  
115. bool TCPServer::bind(const char* ip, int port)  
116. {  
117.     struct sockaddr_in bind_addr;  
118.     int iret = uv_ip4_addr(ip, port, &bind_addr);  
119.     if (iret) {  
120.         errmsg_ = GetUVError(iret);  
121.         LOGE(errmsg_);  
122.         return false;  
123.     }  
124.     iret = uv_tcp_bind(&server_, (const struct sockaddr*)&bind_addr,0);  
125.     if (iret) {  
126.         errmsg_ = GetUVError(iret);  
127.         LOGE(errmsg_);  
128.         return false;  
129.     }  
130.     LOGI("server bind ip="<<ip<<", port="<<port);  
131.     return true;  
132. }  
133.   
134. bool TCPServer::bind6(const char* ip, int port)  
135. {  
136.     struct sockaddr_in6 bind_addr;  
137.     int iret = uv_ip6_addr(ip, port, &bind_addr);  
138.     if (iret) {  
139.         errmsg_ = GetUVError(iret);  
140.         LOGE(errmsg_);  
141.         return false;  
142.     }  
143.     iret = uv_tcp_bind(&server_, (const struct sockaddr*)&bind_addr,0);  
144.     if (iret) {  
145.         errmsg_ = GetUVError(iret);  
146.         LOGE(errmsg_);  
147.         return false;  
148.     }  
149.     LOGI("server bind ip="<<ip<<", port="<<port);  
150.     return true;  
151. }  
152.   
153. bool TCPServer::listen(int backlog)  
154. {  
155.     int iret = uv_listen((uv_stream_t*) &server_, backlog, acceptConnection);  
156.     if (iret) {  
157.         errmsg_ = GetUVError(iret);  
158.         LOGE(errmsg_);  
159.         return false;  
160.     }  
161.     LOGI("server listen");  
162.     return true;  
163. }  
164.   
165. bool TCPServer::Start( const char *ip, int port )  
166. {  
167.     close();  
168.     if (!init()) {  
169.         return false;  
170.     }  
171.     if (!bind(ip,port)) {  
172.         return false;  
173.     }  
174.     if (!listen(SOMAXCONN)) {  
175.         return false;  
176.     }  
177.     if (!run()) {  
178.         return false;  
179.     }  
180.     LOGI("start listen "<<ip<<": "<<port);  
181.     return true;  
182. }  
183.   
184. bool TCPServer::Start6( const char *ip, int port )  
185. {  
186.     close();  
187.     if (!init()) {  
188.         return false;  
189.     }  
190.     if (!bind6(ip,port)) {  
191.         return false;  
192.     }  
193.     if (!listen(SOMAXCONN)) {  
194.         return false;  
195.     }  
196.     if (!run()) {  
197.         return false;  
198.     }  
199.     return true;  
200. }  
201.   
202. //服务器发送函数  
203. int TCPServer::send(int clientid, const char* data, std::size_t len)  
204. {  
205.     auto itfind = clients_list_.find(clientid);  
206.     if (itfind == clients_list_.end()) {  
207.         errmsg_ = "can't find cliendid ";  
208.         errmsg_ += std::to_string((long long)clientid);  
209.         LOGE(errmsg_);  
210.         return -1;  
211.     }  
212.     //自己控制data的生命周期直到write结束  
213.     if (itfind->second->writebuffer.len < len) {  
214.         itfind->second->writebuffer.base = (char*)realloc(itfind->second->writebuffer.base,len);  
215.         itfind->second->writebuffer.len = len;  
216.     }  
217.     memcpy(itfind->second->writebuffer.base,data,len);  
218.     uv_buf_t buf = uv_buf_init((char*)itfind->second->writebuffer.base,len);  
219.     int iret = uv_write(&itfind->second->write_req, (uv_stream_t*)itfind->second->client_handle, &buf, 1, AfterSend);  
220.     if (iret) {  
221.         errmsg_ = GetUVError(iret);  
222.         LOGE(errmsg_);  
223.         return false;  
224.     }  
225.     return true;  
226. }  
227.   
228. //服务器-新客户端函数  
229. void TCPServer::acceptConnection(uv_stream_t *server, int status)  
230. {  
231.     if (!server->data) {  
232.         return;  
233.     }  
234.     TCPServer *tcpsock = (TCPServer *)server->data;  
235.     int clientid = tcpsock->GetAvailaClientID();  
236.     clientdata* cdata = new clientdata(clientid);//uv_close回调函数中释放  
237.     cdata->tcp_server = tcpsock;//保存服务器的信息  
238.     int iret = uv_tcp_init(tcpsock->loop_, cdata->client_handle);//析构函数释放  
239.     if (iret) {  
240.         delete cdata;  
241.         tcpsock->errmsg_ = GetUVError(iret);  
242.         LOGE(tcpsock->errmsg_);  
243.         return;  
244.     }  
245.     iret = uv_accept((uv_stream_t*)&tcpsock->server_, (uv_stream_t*) cdata->client_handle);  
246.     if ( iret) {  
247.         tcpsock->errmsg_ = GetUVError(iret);  
248.         uv_close((uv_handle_t*) cdata->client_handle, NULL);  
249.         delete cdata;  
250.         LOGE(tcpsock->errmsg_);  
251.         return;  
252.     }  
253.     tcpsock->clients_list_.insert(std::make_pair(clientid,cdata));//加入到链接队列  
254.     if (tcpsock->newconcb_) {  
255.         tcpsock->newconcb_(clientid);  
256.     }  
257.     LOGI("new client("<<cdata->client_handle<<") id="<< clientid);  
258.     iret = uv_read_start((uv_stream_t*)cdata->client_handle, onAllocBuffer, AfterServerRecv);//服务器开始接收客户端的数据  
259.     return;  
260. }  
261.   
262. //服务器-接收数据回调函数  
263. void TCPServer::setrecvcb(int clientid, server_recvcb cb )  
264. {  
265.     auto itfind = clients_list_.find(clientid);  
266.     if (itfind != clients_list_.end()) {  
267.         itfind->second->recvcb_ = cb;  
268.     }  
269. }  
270.   
271. //服务器-新链接回调函数  
272. void TCPServer::setnewconnectcb(newconnect cb )  
273. {  
274.     newconcb_ = cb;  
275. }  
276.   
277. //服务器分析空间函数  
278. void TCPServer::onAllocBuffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)  
279. {  
280.     if (!handle->data) {  
281.         return;  
282.     }  
283.     clientdata *client = (clientdata*)handle->data;  
284.     *buf = client->readbuffer;  
285. }  
286.   
287. void TCPServer::AfterServerRecv(uv_stream_t *handle, ssize_t nread, const uv_buf_t* buf)  
288. {  
289.     if (!handle->data) {  
290.         return;  
291.     }  
292.     clientdata *client = (clientdata*)handle->data;//服务器的recv带的是clientdata  
293.     if (nread < 0) {/* Error or EOF */  
294.         TCPServer *server = (TCPServer *)client->tcp_server;  
295.         if (nread == UV_EOF) {  
296.             fprintf(stdout,"客户端(%d)连接断开，关闭此客户端\n",client->client_id);  
297.             LOGW("客户端("<<client->client_id<<")主动断开");  
298.         } else if (nread == UV_ECONNRESET) {  
299.             fprintf(stdout,"客户端(%d)异常断开\n",client->client_id);  
300.             LOGW("客户端("<<client->client_id<<")异常断开");  
301.         } else {  
302.             fprintf(stdout,"%s\n",GetUVError(nread));  
303.             LOGW("客户端("<<client->client_id<<")异常断开："<<GetUVError(nread));  
304.         }  
305.         server->DeleteClient(client->client_id);//连接断开，关闭客户端  
306.         return;  
307.     } else if (0 == nread)  {/* Everything OK, but nothing read. */  
308.   
309.     } else if (client->recvcb_) {  
310.         client->recvcb_(client->client_id,buf->base,nread);  
311.     }  
312. }  
313.   
314. //服务器与客户端一致  
315. void TCPServer::AfterSend(uv_write_t *req, int status)  
316. {  
317.     if (status < 0) {  
318.         LOGE("发送数据有误:"<<GetUVError(status));  
319.         fprintf(stderr, "Write error %s\n", GetUVError(status));  
320.     }  
321. }  
322.   
323. void TCPServer::AfterServerClose(uv_handle_t *handle)  
324. {  
325.     //服务器,不需要做什么  
326. }  
327.   
328. void TCPServer::AfterClientClose(uv_handle_t *handle)  
329. {  
330.     clientdata *cdata = (clientdata*)handle->data;  
331.     LOGI("client "<<cdata->client_id<<" had closed.");  
332.     delete cdata;  
333. }  
334.   
335. int TCPServer::GetAvailaClientID() const  
336. {  
337.     static int s_id = 0;  
338.     return ++s_id;  
339. }  
340.   
341. bool TCPServer::DeleteClient( int clientid )  
342. {  
343.     uv_mutex_lock(&mutex_handle_);  
344.     auto itfind = clients_list_.find(clientid);  
345.     if (itfind == clients_list_.end()) {  
346.         errmsg_ = "can't find client ";  
347.         errmsg_ += std::to_string((long long)clientid);  
348.         LOGE(errmsg_);  
349.         uv_mutex_unlock(&mutex_handle_);  
350.         return false;  
351.     }  
352.     if (uv_is_active((uv_handle_t*)itfind->second->client_handle)) {  
353.         uv_read_stop((uv_stream_t*)itfind->second->client_handle);  
354.     }  
355.     uv_close((uv_handle_t*)itfind->second->client_handle,AfterClientClose);  
356.   
357.     clients_list_.erase(itfind);  
358.     LOGI("删除客户端"<<clientid);  
359.     uv_mutex_unlock(&mutex_handle_);  
360.     return true;  
361. }  
362.   
363.   
364. void TCPServer::StartLog( const char* logpath /*= nullptr*/ )  
365. {  
366.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerMonthdir(LOG4Z_MAIN_LOGGER_ID, true);  
367.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerDisplay(LOG4Z_MAIN_LOGGER_ID,false);  
368.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerLevel(LOG4Z_MAIN_LOGGER_ID,LOG_LEVEL_DEBUG);  
369.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerLimitSize(LOG4Z_MAIN_LOGGER_ID,100);  
370.     if (logpath) {  
371.         zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerPath(LOG4Z_MAIN_LOGGER_ID,logpath);  
372.     }  
373.     zsummer::log4z::ILog4zManager::GetInstance()->Start();  
374. }  
375.   
376.   
377. /*****************************************TCP Client*************************************************************/  
378. TCPClient::TCPClient(uv_loop_t* loop)  
379.     :recvcb_(nullptr),userdata_(nullptr)  
380.     ,connectstatus_(CONNECT_DIS)  
381.     , isinit_(false)  
382. {  
383.     readbuffer_ = uv_buf_init((char*) malloc(BUFFERSIZE), BUFFERSIZE);  
384.     writebuffer_ = uv_buf_init((char*) malloc(BUFFERSIZE), BUFFERSIZE);  
385.     loop_ = loop;  
386.     connect_req_.data = this;  
387.     write_req_.data = this;  
388. }  
389.   
390.   
391. TCPClient::~TCPClient()  
392. {  
393.     free(readbuffer_.base);  
394.     readbuffer_.base = nullptr;  
395.     readbuffer_.len = 0;  
396.     free(writebuffer_.base);  
397.     writebuffer_.base = nullptr;  
398.     writebuffer_.len = 0;  
399.     close();  
400.     LOGI("客户端("<<this<<")退出");  
401. }  
402. //初始化与关闭--服务器与客户端一致  
403. bool TCPClient::init()  
404. {  
405.     if (isinit_) {  
406.         return true;  
407.     }  
408.   
409.     if (!loop_) {  
410.         errmsg_ = "loop is null on tcp init.";  
411.         LOGE(errmsg_);  
412.         return false;  
413.     }  
414.     int iret = uv_tcp_init(loop_,&client_);  
415.     if (iret) {  
416.         errmsg_ = GetUVError(iret);  
417.         LOGE(errmsg_);  
418.         return false;  
419.     }  
420.     iret = uv_mutex_init(&write_mutex_handle_);  
421.     if (iret) {  
422.         errmsg_ = GetUVError(iret);  
423.         LOGE(errmsg_);  
424.         return false;  
425.     }  
426.     isinit_ = true;  
427.     fprintf(stdout,"客户端(%p) init type = %d\n",&client_,client_.type);  
428.     client_.data = this;  
429.     //iret = uv_tcp_keepalive(&client_, 1, 60);//  
430.     //if (iret) {  
431.     //    errmsg_ = GetUVError(iret);  
432.     //    return false;  
433.     //}  
434.     LOGI("客户端("<<this<<")Init");  
435.     return true;  
436. }  
437.   
438. void TCPClient::close()  
439. {  
440.     if (!isinit_) {  
441.         return;  
442.     }  
443.     uv_mutex_destroy(&write_mutex_handle_);  
444.     uv_close((uv_handle_t*) &client_, AfterClose);  
445.     LOGI("客户端("<<this<<")close");  
446.     isinit_ = false;  
447. }  
448.   
449. bool TCPClient::run(int status)  
450. {  
451.     LOGI("客户端("<<this<<")run");  
452.     int iret = uv_run(loop_,(uv_run_mode)status);  
453.     if (iret) {  
454.         errmsg_ = GetUVError(iret);  
455.         LOGE(errmsg_);  
456.         return false;  
457.     }  
458.     return true;  
459. }  
460.   
461. //属性设置--服务器与客户端一致  
462. bool TCPClient::setNoDelay(bool enable)  
463. {  
464.     //http://blog.youkuaiyun.com/u011133100/article/details/21485983  
465.     int iret = uv_tcp_nodelay(&client_, enable ? 1 : 0);  
466.     if (iret) {  
467.         errmsg_ = GetUVError(iret);  
468.         LOGE(errmsg_);  
469.         return false;  
470.     }  
471.     return true;  
472. }  
473.   
474. bool TCPClient::setKeepAlive(int enable, unsigned int delay)  
475. {  
476.     int iret = uv_tcp_keepalive(&client_, enable , delay);  
477.     if (iret) {  
478.         errmsg_ = GetUVError(iret);  
479.         LOGE(errmsg_);  
480.         return false;  
481.     }  
482.     return true;  
483. }  
484.   
485. //作为client的connect函数  
486. bool TCPClient::connect(const char* ip, int port)  
487. {  
488.     close();  
489.     init();  
490.     connectip_ = ip;  
491.     connectport_ = port;  
492.     LOGI("客户端("<<this<<")start connect to server("<<ip<<":"<<port<<")");  
493.     int iret = uv_thread_create(&connect_threadhanlde_, ConnectThread, this);//触发AfterConnect才算真正连接成功，所以用线程  
494.     if (iret) {  
495.         errmsg_ = GetUVError(iret);  
496.         LOGE(errmsg_);  
497.         return false;  
498.     }  
499.     while ( connectstatus_ == CONNECT_DIS) {  
500. #if defined (WIN32) || defined(_WIN32)  
501.         Sleep(100);  
502. #else  
503.         usleep((100) * 1000)  
504. #endif  
505.     }  
506.     return connectstatus_ == CONNECT_FINISH;  
507. }  
508.   
509. bool TCPClient::connect6(const char* ip, int port)  
510. {  
511.     close();  
512.     init();  
513.     connectip_ = ip;  
514.     connectport_ = port;  
515.     LOGI("客户端("<<this<<")start connect to server("<<ip<<":"<<port<<")");  
516.     int iret = uv_thread_create(&connect_threadhanlde_, ConnectThread6, this);//触发AfterConnect才算真正连接成功，所以用线程  
517.     if (iret) {  
518.         errmsg_ = GetUVError(iret);  
519.         LOGE(errmsg_);  
520.         return false;  
521.     }  
522.     while ( connectstatus_ == CONNECT_DIS) {  
523.         //fprintf(stdout,"client(%p) wait, connect status %d\n",this,connectstatus_);  
524. #if defined (WIN32) || defined(_WIN32)  
525.         Sleep(100);  
526. #else  
527.         usleep((100) * 1000)  
528. #endif  
529.     }  
530.     return connectstatus_ == CONNECT_FINISH;  
531. }  
532.   
533. void TCPClient::ConnectThread( void* arg )  
534. {  
535.     TCPClient *pclient = (TCPClient*)arg;  
536.     fprintf(stdout,"client(%p) ConnectThread start\n",pclient);  
537.     struct sockaddr_in bind_addr;  
538.     int iret = uv_ip4_addr(pclient->connectip_.c_str(), pclient->connectport_, &bind_addr);  
539.     if (iret) {  
540.         pclient->errmsg_ = GetUVError(iret);  
541.         LOGE(pclient->errmsg_);  
542.         return;  
543.     }  
544.     iret = uv_tcp_connect(&pclient->connect_req_, &pclient->client_, (const sockaddr*)&bind_addr, AfterConnect);  
545.     if (iret) {  
546.         pclient->errmsg_ = GetUVError(iret);  
547.         LOGE(pclient->errmsg_);  
548.         return;  
549.     }  
550.     fprintf(stdout,"client(%p) ConnectThread end, connect status %d\n",pclient, pclient->connectstatus_);  
551.     pclient->run();  
552. }  
553.   
554.   
555. void TCPClient::ConnectThread6( void* arg )  
556. {  
557.     TCPClient *pclient = (TCPClient*)arg;  
558.     LOGI("客户端("<<pclient<<")Enter Connect Thread.");  
559.     fprintf(stdout,"client(%p) ConnectThread start\n",pclient);  
560.     struct sockaddr_in6 bind_addr;  
561.     int iret = uv_ip6_addr(pclient->connectip_.c_str(), pclient->connectport_, &bind_addr);  
562.     if (iret) {  
563.         pclient->errmsg_ = GetUVError(iret);  
564.         LOGE(pclient->errmsg_);  
565.         return;  
566.     }  
567.     iret = uv_tcp_connect(&pclient->connect_req_, &pclient->client_, (const sockaddr*)&bind_addr, AfterConnect);  
568.     if (iret) {  
569.         pclient->errmsg_ = GetUVError(iret);  
570.         LOGE(pclient->errmsg_);  
571.         return;  
572.     }  
573.     fprintf(stdout,"client(%p) ConnectThread end, connect status %d\n",pclient, pclient->connectstatus_);  
574.     LOGI("客户端("<<pclient<<")Leave Connect Thread. connect status "<<pclient->connectstatus_);  
575.     pclient->run();  
576. }  
577.   
578. void TCPClient::AfterConnect(uv_connect_t* handle, int status)  
579. {  
580.     fprintf(stdout,"start after connect\n");  
581.     TCPClient *pclient = (TCPClient*)handle->handle->data;  
582.     if (status) {  
583.         pclient->connectstatus_ = CONNECT_ERROR;  
584.         fprintf(stdout,"connect error:%s\n",GetUVError(status));  
585.         return;  
586.     }  
587.   
588.     int iret = uv_read_start(handle->handle, onAllocBuffer, AfterClientRecv);//客户端开始接收服务器的数据  
589.     if (iret) {  
590.         fprintf(stdout,"uv_read_start error:%s\n",GetUVError(iret));  
591.         pclient->connectstatus_ = CONNECT_ERROR;  
592.     } else {  
593.         pclient->connectstatus_ = CONNECT_FINISH;  
594.     }  
595.     LOGI("客户端("<<pclient<<")run");  
596.     fprintf(stdout,"end after connect\n");  
597. }  
598.   
599. //客户端的发送函数  
600. int TCPClient::send(const char* data, std::size_t len)  
601. {  
602.     //自己控制data的生命周期直到write结束  
603.     if (!data || len <= 0) {  
604.         errmsg_ = "send data is null or len less than zero.";  
605.         return 0;  
606.     }  
607.   
608.     uv_mutex_lock(&write_mutex_handle_);  
609.     if (writebuffer_.len < len) {  
610.         writebuffer_.base = (char*)realloc(writebuffer_.base,len);  
611.         writebuffer_.len = len;  
612.     }  
613.     memcpy(writebuffer_.base,data,len);  
614.     uv_buf_t buf = uv_buf_init((char*)writebuffer_.base,len);  
615.     int iret = uv_write(&write_req_, (uv_stream_t*)&client_, &buf, 1, AfterSend);  
616.     if (iret) {  
617.         uv_mutex_unlock(&write_mutex_handle_);  
618.         errmsg_ = GetUVError(iret);  
619.         LOGE(errmsg_);  
620.         return false;  
621.     }  
622.     return true;  
623. }  
624.   
625. //客户端-接收数据回调函数  
626. void TCPClient::setrecvcb(client_recvcb cb, void* userdata )  
627. {  
628.     recvcb_ = cb;  
629.     userdata_ = userdata;  
630. }  
631.   
632. //客户端分析空间函数  
633. void TCPClient::onAllocBuffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)  
634. {  
635.     if (!handle->data) {  
636.         return;  
637.     }  
638.     TCPClient *client = (TCPClient*)handle->data;  
639.     *buf = client->readbuffer_;  
640. }  
641.   
642.   
643. void TCPClient::AfterClientRecv(uv_stream_t *handle, ssize_t nread, const uv_buf_t* buf)  
644. {  
645.     if (!handle->data) {  
646.         return;  
647.     }  
648.     TCPClient *client = (TCPClient*)handle->data;//服务器的recv带的是TCPClient  
649.     if (nread < 0) {  
650.         if (nread == UV_EOF) {  
651.             fprintf(stdout,"服务器(%p)主动断开\n",handle);  
652.             LOGW("服务器主动断开");  
653.         } else if (nread == UV_ECONNRESET) {  
654.             fprintf(stdout,"服务器(%p)异常断开\n",handle);  
655.             LOGW("服务器异常断开");  
656.         } else {  
657.             fprintf(stdout,"服务器(%p)异常断开:%s\n",handle,GetUVError(nread));  
658.             LOGW("服务器异常断开"<<GetUVError(nread));  
659.         }  
660.         uv_close((uv_handle_t*)handle, AfterClose);  
661.         return;  
662.     }  
663.     if (nread > 0 && client->recvcb_) {  
664.         client->recvcb_(buf->base,nread,client->userdata_);  
665.     }  
666. }  
667.   
668. //服务器与客户端一致  
669. void TCPClient::AfterSend(uv_write_t *req, int status)  
670. {  
671.     TCPClient *client = (TCPClient *)req->handle->data;  
672.     uv_mutex_unlock(&client->write_mutex_handle_);  
673.     if (status < 0) {  
674.         LOGE("发送数据有误:"<<GetUVError(status));  
675.         fprintf(stderr, "Write error %s\n", GetUVError(status));  
676.     }  
677. }  
678. //服务器与客户端一致  
679. void TCPClient::AfterClose(uv_handle_t *handle)  
680. {  
681.     fprintf(stdout,"客户端(%p)已close\n",handle);  
682.     LOGI("客户端("<<handle<<")已close");  
683. }  
684.   
685. void TCPClient::StartLog( const char* logpath /*= nullptr*/ )  
686. {  
687.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerMonthdir(LOG4Z_MAIN_LOGGER_ID, true);  
688.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerDisplay(LOG4Z_MAIN_LOGGER_ID,false);  
689.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerLevel(LOG4Z_MAIN_LOGGER_ID,LOG_LEVEL_DEBUG);  
690.     zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerLimitSize(LOG4Z_MAIN_LOGGER_ID,100);  
691.     if (logpath) {  
692.         zsummer::log4z::ILog4zManager::GetInstance()->SetLoggerPath(LOG4Z_MAIN_LOGGER_ID,logpath);  
693.     }  
694.     zsummer::log4z::ILog4zManager::GetInstance()->Start();  
695. }  
696.   
697. }  

按照例子，客户端可以并发20多路，超过uv_write就会assert出错，未找到原因

服务器可以接收几十路连接。万百上千路未测试过，因为没有模拟环境。