加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 百科 > 正文

epoll实现Reactor模式

发布时间：2020-12-15 07:25:28 所属栏目：百科 来源：网络整理
导读：转自：http://blog.csdn.net/analogous_love/article/details/53319815 最近一直在看游双的《高性能Linux服务器编程》一书，下载链接：http://download.csdn.net/detail/analogous_love/9673008 书上是这么介绍Reactor模式的： 按照这个思路，我写个简单的练

转自：http://blog.csdn.net/analogous_love/article/details/53319815

最近一直在看游双的《高性能Linux服务器编程》一书，下载链接：http://download.csdn.net/detail/analogous_love/9673008

书上是这么介绍Reactor模式的：




按照这个思路，我写个简单的练习：

[cpp] view plain copy
  1. /**
  2. *@desc:用reactor模式练习服务器程序，main.cpp
  3. *@author:zhangyl
  4. *@date:2016.11.23
  5. */
  7. #include<iostream>
  8. #include<string.h>
  9. #include<sys/types.h>
  10. #include<sys/socket.h>
  11. #include<netinet/in.h>
  12. #include<arpa/inet.h>//forhtonl()andhtons()
  13. #include<unistd.h>
  14. #include<fcntl.h>
  15. #include<sys/epoll.h>
  16. #include<signal.h>//forsignal()
  17. #include<pthread.h>
  18. #include<semaphore.h>
  19. #include<list>
  20. #include<errno.h>
  21. #include<time.h>
  22. #include<sstream>
  23. #include<iomanip>//forstd::setw()/setfill()
  24. #include<stdlib.h>
  26. #defineWORKER_THREAD_NUM5
  27. #definemin(a,b)((a<=b)?(a):(b))
  28. intg_epollfd=0;
  29. boolg_bStop=false;
  30. intg_listenfd=0;
  31. pthread_tg_acceptthreadid=0;
  32. pthread_tg_threadid[WORKER_THREAD_NUM]={0};
  33. pthread_cond_tg_acceptcond;
  34. pthread_mutex_tg_acceptmutex;
  35. pthread_cond_tg_cond/*=PTHREAD_COND_INITIALIZER*/;
  36. pthread_mutex_tg_mutex/*=PTHREAD_MUTEX_INITIALIZER*/;
  37. pthread_mutex_tg_clientmutex;
  38. std::list<int>g_listClients;
  39. voidprog_exit(intsigno)
  40. {
  41. ::signal(SIGINT,SIG_IGN);
  42. ::signal(SIGKILL,SIG_IGN);
  43. ::signal(SIGTERM,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> std::cout<<"programrecvsignal"<<signo<<"toexit."<<std::endl;
  44. g_bStop=true;
  45. ::epoll_ctl(g_epollfd,EPOLL_CTL_DEL,g_listenfd,NULL);
  46. //TODO:是否需要先调用shutdown()一下？
  47. ::shutdown(g_listenfd,SHUT_RDWR);
  48. ::close(g_listenfd);
  49. ::close(g_epollfd);
  50. ::pthread_cond_destroy(&g_acceptcond);
  51. ::pthread_mutex_destroy(&g_acceptmutex);
  52. ::pthread_cond_destroy(&g_cond);
  53. ::pthread_mutex_destroy(&g_mutex);
  54. ::pthread_mutex_destroy(&g_clientmutex);
  55. }
  56. boolcreate_server_listener(constchar*ip,shortport)
  57. g_listenfd=::socket(AF_INET,SOCK_STREAM|SOCK_NONBLOCK,0);
  58. if(g_listenfd==-1)
  59. returninton=1;
  60. ::setsockopt(g_listenfd,SOL_SOCKET,SO_REUSEADDR,(char*)&on,sizeof(on));
  61. ::setsockopt(g_listenfd,SO_REUSEPORT,153); background-color:inherit; font-weight:bold">sizeof(on));
  62. structsockaddr_inservaddr;
  63. memset(&servaddr,sizeof(servaddr));
  64. servaddr.sin_family=AF_INET;
  65. servaddr.sin_addr.s_addr=inet_addr(ip);
  66. servaddr.sin_port=htons(port);
  67. if(::bind(g_listenfd,(sockaddr*)&servaddr,153); background-color:inherit; font-weight:bold">sizeof(servaddr))==-1)
  68. if(::listen(g_listenfd,50)==-1)
  69. false;
  70. g_epollfd=::epoll_create(1);
  71. if(g_epollfd==-1)
  72. structepoll_evente;
  73. memset(&e,153); background-color:inherit; font-weight:bold">sizeof(e));
  74. e.events=EPOLLIN|EPOLLRDHUP;
  75. e.data.fd=g_listenfd;
  76. if(::epoll_ctl(g_epollfd,EPOLL_CTL_ADD,&e)==-1)
  77. }
  78. voidrelease_client(intclientfd)
  79. {
  80. std::cout<<"releaseclientsocketfailedascallepoll_ctlfailed"<<std::endl;
  81. ::close(clientfd);
  82. void*accept_thread_func(void*arg)
  83. while(!g_bStop)
  84. ::pthread_mutex_lock(&g_acceptmutex);
  85. ::pthread_cond_wait(&g_acceptcond,&g_acceptmutex);
  86. //::pthread_mutex_lock(&g_acceptmutex);
  87. //std::cout<<"runloopinaccept_thread_func"<<std::endl;
  88. structsockaddr_inclientaddr;
  89. socklen_taddrlen;
  90. intnewfd=::accept(g_listenfd,(structsockaddr*)&clientaddr,&addrlen);
  91. ::pthread_mutex_unlock(&g_acceptmutex);
  92. if(newfd==-1)
  93. continue;
  94. std::cout<<"newclientconnected:"<<::inet_ntoa(clientaddr.sin_addr)<<":"<<::ntohs(clientaddr.sin_port)<<std::endl;
  95. //将新socket设置为non-blocking
  96. intoldflag=::fcntl(newfd,F_GETFL,0);
  97. intnewflag=oldflag|O_NONBLOCK;
  98. if(::fcntl(newfd,F_SETFL,newflag)==-1)
  99. std::cout<<"fcntlerror,oldflag="<<oldflag<<",newflag="<<newflag<<std::endl;
  100. e.events=EPOLLIN|EPOLLRDHUP|EPOLLET;
  101. e.data.fd=newfd;
  102. std::cout<<"epoll_ctlerror,fd="<<newfd<<std::endl;
  103. returnNULL;
  104. void*worker_thread_func(intclientfd;
  105. ::pthread_mutex_lock(&g_clientmutex);
  106. while(g_listClients.empty())
  107. ::pthread_cond_wait(&g_cond,&g_clientmutex);
  108. clientfd=g_listClients.front();
  109. g_listClients.pop_front();
  110. pthread_mutex_unlock(&g_clientmutex);
  111. //gdb调试时不能实时刷新标准输出，用这个函数刷新标准输出，使信息在屏幕上实时显示出来
  112. std::cout<<std::endl;
  113. std::stringstrclientmsg;
  114. charbuff[256];
  115. boolbError=while(true)
  116. memset(buff,153); background-color:inherit; font-weight:bold">sizeof(buff));
  117. intnRecv=::recv(clientfd,buff,256,0);
  118. if(nRecv==-1)
  119. if(errno==EWOULDBLOCK)
  120. break;
  121. else
  122. std::cout<<"recverror,clientdisconnected,fd="<<clientfd<<std::endl;
  123. release_client(clientfd);
  124. bError=true;
  125. //对端关闭了socket，这端也关闭。
  126. elseif(nRecv==0)
  127. std::cout<<"peerclosed,108); list-style-type:decimal-leading-zero; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> strclientmsg+=buff;
  128. //出错了，就不要再继续往下执行了
  129. if(bError)
  130. std::cout<<"clientmsg:"<<strclientmsg;
  131. //将消息加上时间标签后发回
  132. time_tnow=time(NULL);
  133. structtm*nowstr=localtime(&now);
  134. std::ostringstreamostimestr;
  135. ostimestr<<"["<<nowstr->tm_year+1900<<"-"
  136. <<std::setw(2)<<std::setfill('0')<<nowstr->tm_mon+1<<"-"
  137. <<std::setw(2)<<std::setfill('0')<<nowstr->tm_mday<<""
  138. <<std::setw(2)<<std::setfill('0')<<nowstr->tm_hour<<":"
  139. <<std::setw(2)<<std::setfill('0')<<nowstr->tm_min<<":"
  140. <<std::setw(2)<<std::setfill('0')<<nowstr->tm_sec<<"]serverreply:";
  141. strclientmsg.insert(0,ostimestr.str());
  142. intnSent=::send(clientfd,strclientmsg.c_str(),strclientmsg.length(),153); background-color:inherit; font-weight:bold">if(nSent==-1)
  143. if(errno==EWOULDBLOCK)
  144. ::sleep(10);
  145. continue;
  146. std::cout<<"senderror,153); background-color:inherit; font-weight:bold">break;
  147. std::cout<<"send:"<<strclientmsg;
  148. strclientmsg.erase(0,nSent);
  149. if(strclientmsg.empty())
  150. returnNULL;
  151. voiddaemon_run()
  152. intpid;
  153. signal(SIGCHLD,0); background-color:inherit">//1）在父进程中，fork返回新创建子进程的进程ID；
  154. //2）在子进程中，fork返回0；
  155. //3）如果出现错误，fork返回一个负值；
  156. pid=fork();
  157. if(pid<0)
  158. std::cout<<"forkerror"<<std::endl;
  159. exit(-1);
  160. //父进程退出，子进程独立运行
  161. if(pid>0){
  162. exit(0);
  163. //之前parent和child运行在同一个session里,parent是会话（session）的领头进程,
  164. //parent进程作为会话的领头进程，如果exit结束执行的话，那么子进程会成为孤儿进程，并被init收养。
  165. //执行setsid()之后,child将重新获得一个新的会话(session)id。
  166. //这时parent退出之后,将不会影响到child了。
  167. setsid();
  168. intfd;
  169. fd=open("/dev/null",O_RDWR,153); background-color:inherit; font-weight:bold">if(fd!=-1)
  170. dup2(fd,STDIN_FILENO);
  171. dup2(fd,STDOUT_FILENO);
  172. if(fd>2)
  173. close(fd);
  174. intmain(intargc,87); background-color:inherit; font-weight:bold">char*argv[])
  175. shortport=0;
  176. intch;
  177. boolbdaemon=while((ch=getopt(argc,argv,"p:d"))!=-1)
  178. switch(ch)
  179. case'd':
  180. bdaemon=case'p':
  181. port=atol(optarg);
  182. if(bdaemon)
  183. daemon_run();
  184. if(port==0)
  185. port=12345;
  186. if(!create_server_listener("0.0.0.0",port))
  187. std::cout<<"Unabletocreatelistenserver:ip=0.0.0.0,port="<<port<<"."<<std::endl;
  188. return-1;
  189. //设置信号处理
  190. signal(SIGPIPE,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> signal(SIGINT,prog_exit);
  191. signal(SIGKILL,prog_exit);
  192. signal(SIGTERM,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::pthread_cond_init(&g_acceptcond,108); list-style-type:decimal-leading-zero; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::pthread_mutex_init(&g_acceptmutex,NULL);
  193. ::pthread_cond_init(&g_cond,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::pthread_mutex_init(&g_mutex,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::pthread_mutex_init(&g_clientmutex,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::pthread_create(&g_acceptthreadid,NULL,accept_thread_func,0); background-color:inherit">//启动工作线程
  194. for(inti=0;i<WORKER_THREAD_NUM;++i)
  195. ::pthread_create(&g_threadid[i],worker_thread_func,153); background-color:inherit; font-weight:bold">structepoll_eventev[1024];
  196. intn=::epoll_wait(g_epollfd,ev,1024,10);
  197. if(n==0)
  198. if(n<0)
  199. std::cout<<"epoll_waiterror"<<std::endl;
  200. intm=min(n,1024);
  201. inti=0;i<m;++i)
  202. //通知接收连接线程接收新连接
  203. if(ev[i].data.fd==g_listenfd)
  204. pthread_cond_signal(&g_acceptcond);
  205. //通知普通工作线程接收数据
  206. else
  207. pthread_mutex_lock(&g_clientmutex);
  208. g_listClients.push_back(ev[i].data.fd);
  209. pthread_mutex_unlock(&g_clientmutex);
  210. pthread_cond_signal(&g_cond);
  211. //std::cout<<"signal"<<std::endl;
  212. return0;
  213. }


程序的功能一个简单的echo服务：客户端连接上服务器之后，给服务器发送信息，服务器加上时间戳等信息后返回给客户端。使用到的知识点有：

1. 条件变量

2.epoll的边缘触发模式


程序的大致框架是：

1. 主线程只负责监听侦听socket上是否有新连接，如果有新连接到来，交给一个叫accept的工作线程去接收新连接，并将新连接socket绑定到主线程使用epollfd上去。

2. 主线程如果侦听到客户端的socket上有可读事件，则通知另外五个工作线程去接收处理客户端发来的数据，并将数据加上时间戳后发回给客户端。

3. 可以通过传递-p port来设置程序的监听端口号；可以通过传递-d来使程序以daemon模式运行在后台。这也是标准linux daemon模式的书写方法。


程序难点和需要注意的地方是：

1. 条件变量为了防止虚假唤醒，一定要在一个循环里面调用pthread_cond_wait()函数，我在worker_thread_func()中使用了：

copy


在accept_thread_func()函数里面我没有使用循环，这样会有问题吗？

2. 使用条件变量pthread_cond_wait()函数的时候一定要先获得与该条件变量相关的mutex，即像下面这样的结构：

copy
mutex_lock(...);
  • while(conditionis ::pthread_cond_wait(...);
  • //这里可以有其他代码...
  • mutex_unlock(...);
  • //这里可以有其他代码...

    • 因为pthread_cond_wait()如果阻塞的话，它解锁相关mutex和阻塞当前线程这两个动作加在一起是原子的。


    3. 作为服务器端程序最好对侦听socket调用setsocketopt()设置SO_REUSEADDR和SO_REUSEPORT两个标志，因为服务程序有时候会需要重启（比如调试的时候就会不断重启），如果不设置这两个标志的话，绑定端口时就会调用失败。因为一个端口使用后，即使不再使用，因为四次挥手该端口处于TIME_WAIT状态，有大约2min的MSL（Maximum Segment Lifetime，最大存活期）。这2min内，该端口是不能被重复使用的。你的服务器程序上次使用了这个端口号，接着重启，因为这个缘故，你再次绑定这个端口就会失败（bind函数调用失败）。要不你就每次重启时需要等待2min后再试（这在频繁重启程序调试是难以接收的），或者设置这种SO_REUSEADDR和SO_REUSEPORT立即回收端口使用。

    其实，SO_REUSEADDR在windows上和Unix平台上还有些细微的区别，我在libevent源码中看到这样的描述：

    copy
    intevutil_make_listen_socket_reuseable(evutil_socket_tsock)
  • #ifndefWIN32
  • intone=1;
  • /*REUSEADDRonUnixmeans,"don'thangontothisaddressafterthe
  • *listenerisclosed."OnWindows,though,itmeans"don'tkeepother
  • *processesfrombindingtothisaddresswhilewe'reusingit.*/
  • returnsetsockopt(sock,153); background-color:inherit; font-weight:bold">void*)&one,
  • (ev_socklen_t)sizeof(one));
  • #else
  • #endif
  • }
    • 注意注释部分， 在Unix平台上设置这个选项意味着，任意进程可以复用该地址；而在windows，不要阻止其他进程复用该地址。也就是在在Unix平台上，如果不设置这个选项，任意进程在一定时间内，不能bind该地址；在windows平台上，在一定时间内，其他进程不能bind该地址，而本进程却可以再次bind该地址。


    4. epoll_wait对新连接socket使用的是边缘触发模式EPOLLET（edge trigger），而不是默认的水平触发模式（level trigger)。因为如果采取水平触发模式的话，主线程检测到某个客户端socket数据可读时，通知工作线程去收取该socket上的数据，这个时候主线程继续循环，只要在工作线程没有将该socket上数据全部收完，或者在工作线程收取数据的过程中，客户端有新数据到来，主线程会继续发通知（通过pthread_cond_signal()）函数，再次通知工作线程收取数据。这样会可能导致多个工作线程同时调用recv函数收取该客户端socket上的数据，这样产生的结果将会导致数据错乱。

    相反，采取边缘触发模式，只有等某个工作线程将那个客户端socket上数据全部收取完毕，主线程的epoll_wait才可能会再次触发来通知工作线程继续收取那个客户端socket新来的数据。


    5. 代码中有这样一行：

    copy
    std::cout<<std::endl;

    如果不加上这一行，正常运行服务器程序，程序中要打印到控制台的信息都会打印出来，但是如果用gdb调试状态下，程序的所有输出就不显示了。我不知道这是不是gdb的一个bug，所以这里加上std::endl来输出一个换行符并flush标准输出，让输出显示出来。（std::endl不仅是输出一个换行符而且是同时刷新输出，相当于fflush()函数）。


    程序我部署起来了，你可以使用linux的nc命令或自己写程序连接服务器来查看程序效果，当然也可以使用telnet命令，方法：

    linux:

    nc120.55.94.78 12345

    或

    telnet120.55.94.78 12345

    然后就可以给服务器自由发送数据了，服务器会给你发送的信息加上时间戳返回给你。效果如图：



    另外我将这个代码改写了成纯C++11版本，使用CMake编译，为了支持编译必须加上这-std=c++11：

    CMakeLists.txt代码如下：

    copy
    cmake_minimum_required(VERSION2.8)
  • PROJECT(myreactorserver)
  • AUX_SOURCE_DIRECTORY(./SRC_LIST)
  • SET(EXECUTABLE_OUTPUT_PATH./)
  • ADD_DEFINITIONS(-g-W-Wall-Wno-deprecated-DLINUX-D_REENTRANT-D_FILE_OFFSET_BITS=64-DAC_HAS_INFO-DAC_HAS_WARNING-DAC_HAS_ERROR-DAC_HAS_CRITICAL-DTIXML_USE_STL-DHAVE_CXX_STDHEADERS${CMAKE_CXX_FLAGS}-std=c++11)
  • INCLUDE_DIRECTORIES(
  • ./
  • )
  • LINK_DIRECTORIES(
  • ./
  • )
  • set(
  • main.cpp
  • myreator.cpp
  • ADD_EXECUTABLE(myreactorserver${SRC_LIST})
  • TARGET_LINK_LIBRARIES(myreactorserverpthread)

    • myreactor.h文件内容：

    copy
    *@desc:myreactor头文件,myreactor.h
  • *@date:2016.12.03
  • #ifndef__MYREACTOR_H__
  • #define__MYREACTOR_H__
  • #include<memory>
  • #include<thread>
  • #include<mutex>
  • #include<condition_variable>
  • classCMyReactor
  • public:
  • CMyReactor();
  • ~CMyReactor();
  • boolinit(shortnport);
  • booluninit();
  • boolclose_client(intclientfd);
  • staticvoid*main_loop(void*p);
  • private:
  • //nocopyable
  • CMyReactor(constCMyReactor&rhs);
  • CMyReactor&operator=(constCMyReactor&rhs);
  • shortport);
  • voidaccept_thread_proc(CMyReactor*pReatcor);
  • voidworker_thread_proc(CMyReactor*pReatcor);
  • //C11语法可以在这里初始化
  • intm_listenfd=0;
  • intm_epollfd=0;
  • boolm_bStop= std::shared_ptr<std::thread>m_acceptthread;
  • std::shared_ptr<std::thread>m_workerthreads[WORKER_THREAD_NUM];
  • std::condition_variablem_acceptcond;
  • std::mutexm_acceptmutex;
  • std::condition_variablem_workercond;
  • std::mutexm_workermutex;
  • std::list<int>m_listClients;
  • };
  • #endif//!__MYREACTOR_H__

    • myreactor.cpp文件内容：

    copy
    *@desc:myreactor实现文件,myreactor.cpp
  • #include"myreactor.h"
  • #include<fcntl.h>
  • #include<sys/epoll.h>
  • #include<unistd.h>
  • #definemin(a,b)((a<=b)?(a):(b))
  • CMyReactor::CMyReactor()
  • //m_listenfd=0;
  • //m_epollfd=0;
  • //m_bStop=false;
  • CMyReactor::~CMyReactor()
  • boolCMyReactor::init(shortnport)
  • if(!create_server_listener(ip,nport))
  • std::cout<<"Unabletobind:"<<ip<<":"<<nport<<"."<<std::endl;
  • std::cout<<"mainthreadid="<<std::this_thread::get_id()<<std::endl;
  • //启动接收新连接的线程
  • m_acceptthread.reset(newstd::thread(CMyReactor::accept_thread_proc,153); background-color:inherit; font-weight:bold">this));
  • //启动工作线程
  • for(auto&t:m_workerthreads)
  • t.reset(thread(CMyReactor::worker_thread_proc,153); background-color:inherit; font-weight:bold">this));
  • boolCMyReactor::uninit()
  • m_bStop= m_acceptcond.notify_one();
  • m_workercond.notify_all();
  • m_acceptthread->join();
  • t->join();
  • ::epoll_ctl(m_epollfd,m_listenfd,108); list-style-type:decimal-leading-zero; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::shutdown(m_listenfd,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::close(m_listenfd);
  • ::close(m_epollfd);
  • boolCMyReactor::close_client(intclientfd)
  • if(::epoll_ctl(m_epollfd,NULL)==-1)
  • std::cout<<"closeclientsocketfailedascallepoll_ctlfailed"<<std::endl;
  • //returnfalse;
  • ::close(clientfd);
  • void*CMyReactor::main_loop(void*p)
  • CMyReactor*pReatcor=static_cast<CMyReactor*>(p);
  • while(!pReatcor->m_bStop)
  • intn=::epoll_wait(pReatcor->m_epollfd,153); background-color:inherit; font-weight:bold">if(ev[i].data.fd==pReatcor->m_listenfd)
  • pReatcor->m_acceptcond.notify_one();
  • std::unique_lock<std::mutex>guard(pReatcor->m_workermutex);
  • pReatcor->m_listClients.push_back(ev[i].data.fd);
  • pReatcor->m_workercond.notify_one();
  • }//endif
  • //endfor-loop
  • }//endwhile
  • std::cout<<"mainloopexit..."<<std::endl;
  • voidCMyReactor::accept_thread_proc(CMyReactor*pReatcor)
  • std::cout<<"acceptthread,threadid="<<std::this_thread::get_id()<<std::endl;
  • intnewfd;
  • structsockaddr_inclientaddr;
  • socklen_taddrlen;
  • std::unique_lock<std::mutex>guard(pReatcor->m_acceptmutex);
  • pReatcor->m_acceptcond.wait(guard);
  • if(pReatcor->m_bStop)
  • //std::cout<<"runloopinaccept_thread_proc"<<std::endl;
  • newfd=::accept(pReatcor->m_listenfd,(if(newfd==-1)
  • std::cout<<"newclientconnected:"<<::inet_ntoa(clientaddr.sin_addr)<<":"<<::ntohs(clientaddr.sin_port)<<std::endl;
  • //将新socket设置为non-blocking
  • intnewflag=oldflag|O_NONBLOCK;
  • std::cout<<"fcntlerror,newflag="<<newflag<<std::endl;
  • structepoll_evente;
  • memset(&e,153); background-color:inherit; font-weight:bold">sizeof(e));
  • e.events=EPOLLIN|EPOLLRDHUP|EPOLLET;
  • e.data.fd=newfd;
  • if(::epoll_ctl(pReatcor->m_epollfd,&e)==-1)
  • std::cout<<"epoll_ctlerror,fd="<<newfd<<std::endl;
  • std::cout<<"acceptthreadexit..."<<std::endl;
  • voidCMyReactor::worker_thread_proc(CMyReactor*pReatcor)
  • std::cout<<"newworkerthread,153); background-color:inherit; font-weight:bold">while(pReatcor->m_listClients.empty())
  • if(pReatcor->m_bStop)
  • std::cout<<"workerthreadexit..."<<std::endl;
  • return;
  • pReatcor->m_workercond.wait(guard);
  • clientfd=pReatcor->m_listClients.front();
  • pReatcor->m_listClients.pop_front();
  • pReatcor->close_client(clientfd);
  • std::this_thread::sleep_for(std::chrono::milliseconds(10));
  • boolCMyReactor::create_server_listener(shortport)
  • m_listenfd=::socket(AF_INET,0);
  • if(m_listenfd==-1)
  • inton=1;
  • ::setsockopt(m_listenfd,108); list-style-type:decimal-leading-zero; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> ::setsockopt(m_listenfd,153); background-color:inherit; font-weight:bold">structsockaddr_inservaddr;
  • memset(&servaddr,153); background-color:inherit; font-weight:bold">sizeof(servaddr));
  • servaddr.sin_family=AF_INET;
  • servaddr.sin_addr.s_addr=inet_addr(ip);
  • servaddr.sin_port=htons(port);
  • if(::bind(m_listenfd,153); background-color:inherit; font-weight:bold">sizeof(servaddr))==-1)
  • if(::listen(m_listenfd,50)==-1)
  • m_epollfd=::epoll_create(1);
  • if(m_epollfd==-1)
  • e.events=EPOLLIN|EPOLLRDHUP;
  • e.data.fd=m_listenfd;
  • }

    • main.cpp文件内容：

    copy
    *@desc:用reactor模式练习服务器程序
  • #include<stdlib.h>//forexit()
  • #include<sys/stat.h>
  • CMyReactorg_reator;
  • g_reator.uninit();
  • char*argv[])
  • //设置信号处理
  • signal(SIGCHLD,SIG_DFL);
  • signal(SIGPIPE,108); list-style-type:decimal-leading-zero; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> signal(SIGINT,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> signal(SIGKILL,108); list-style-type:decimal-leading-zero; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important; list-style-position:outside!important"> signal(SIGTERM,153); background-color:inherit; font-weight:bold">if(!g_reator.init("0.0.0.0",12345))
  • return-1;
  • g_reator.main_loop(&g_reator);
  • return0;
  • }

    • 完整实例代码下载地址：

    普通版本：https://pan.baidu.com/s/1o82Mkno

    C++11版本：https://pan.baidu.com/s/1dEJdrih

    （编辑：李大同）

    【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
      相关内容
        推荐文章
          站长推荐
          热点阅读

            【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

            建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

            Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同