高并发的epoll+线程池，线程池专注实现业务

我们知道，服务器并发模型通常可分为单线程和多线程模型，这里的线程通常是指“I/O线程”，即负责I/O操作，协调分配任务的“管理线程”，而实际的请求和任务通常交由所谓“工作者线程”处理。通常多线程模型下，每个线程既是I/O线程又是工作者线程。所以这里讨论的是，单I/O线程+多工作者线程的模型，这也是最常用的一种服务器并发模型。我所在的项目中的server代码中，这种模型随处可见。它还有个名字，叫“半同步/半异步“模型，同时，这种模型也是生产者/消费者（尤其是多消费者）模型的一种表现。

这种架构主要是基于I/O多路复用的思想（主要是epoll，select/poll已过时），通过单线程I/O多路复用，可以达到高效并发，同时避免了多线程I/O来回切换的各种开销，思路清晰，易于管理，而基于线程池的多工作者线程，又可以充分发挥和利用多线程的优势，利用线程池，进一步提高资源复用性和避免产生过多线程。

瓶颈在于IO密集度。
线程池你开10个线程当然可以一上来全部accept阻塞住，这样客户端一连上来便会自动激活一个线程去处理，但是设想一下，如果10个线程全部用掉了，第11个客户端就会发生丢弃。这样为了实现”高并发“你得不断加大线程池的数量。这样会带来严重的内存占用和线程切换的时延问题。
于是前置事件轮询设施的方案就应运而生了，
主线程轮询负责IO，作业交给线程池。
在高并发下，10W个客户端上来，就主线程负责accept，放到队列中，不至于发生没有及时握手而丢弃掉连接的情况发生，而作业线程从队列中认领作业，做完回复主线程，主线程负责write。这样可以用极少的系统资源处理大数量连接。
在低并发下，比如2个客户端上来，也不会出现100个线程hold住在那从而发生系统资源浪费的情况。

正确实现基本线程池模型的核心：
主线程负责所有的 I/O 操作，收齐一个请求所有数据之后如果有必要，交给工作线程进行处理。处理完成之后，把需要写回的数据还给主线程去做写回 / 尝试写回数据直到阻塞，然后交回主线程继续。
这里「如果有必要」的意思是：经过测量，确认这个处理过程中所消耗的 CPU 时间（不包括任何 I/O 等待，或者相关的 I/O 等待操作无法用 epoll 接管）相当显著。如果这个处理过程（不包含可接管的 I/O 操作）不显著，则可以直接放在主线程里解决。
这个「必要」与否的前提不过三个词：假设，分析，测量。

所以，一个正确实现的线程池环境钟，用 epoll + non-blocking I/O 代替 select + blocking I/O 的好处是，处理大量 socket 的时候，前者效率比后者高，因为前者不需要每次被唤醒之后重新检查所有 fd 判断哪个 fd 的状态改变可以进行读写了。

关键

1、单I/O 线程epoll

实现单I/O线程的epoll模型是本架构的第一个技术要点，主要思想如下：

单线程创建epoll并等待，有I/O请求（socket）到达时，将其加入epoll并从线程池中取一个空闲工作者线程，将实际的业务交由工作者线程处理。

伪码：

创建一个epoll实例;
while(server running)
{
    epoll等待事件;
    if(新连接到达且是有效连接)
    {
        accept此连接;
        将此连接设置为non-blocking;
　　     为此连接设置event(EPOLLIN | EPOLLET ...);

        将此连接加入epoll监听队列;
        从线程池取一个空闲工作者线程并处理此连接;
    }
    else if(读请求)
    {
        从线程池取一个空闲工作者线程并处理读请求;
    }
    else if(写请求)
    {
        从线程池取一个空闲工作者线程并处理写请求;
    }
    else
        其他事件;     
}

2、线程池实现

server启动时，创建一定数量的工作者线程加入线程池，如（20个），供I/O线程来取用；

每当I/O线程请求空闲工作者线程时，从池中取出一个空闲工作者线程，处理相应请求；

当请求处理完毕，关闭相应I/O连接时，回收相应线程并放回线程池中供下次使用；

若请求空闲工作者线程池时，没有空闲工作者线程，可作如下处理：

(1)若池中"管理"的线程总数不超过最大允许值，可创建一批新的工作者线程加入池中，并返回其中一个供I/O线程使用；

(2)若池中"管理"的线程总数已经达到最大值，不应再继续创建新线程，则等待一小段时间并重试。注意因为I/O线程是单线程且不应被阻塞等待在此处，所以其实对线程池的管理应由一个专门的管理线程完成，包括创建新工作者线程等工作。此时管理线程阻塞等待（如使用条件变量并等待唤醒），一小段时间之后，线程池中应有空闲工作者线程可使用。否则server负荷估计是出了问题。

epoll是linux下高并发服务器的完美方案，因为是基于事件触发的，所以比select快的不只是一个数量级。

单线程epoll，触发量可达到15000，但是加上业务后，因为大多数业务都与数据库打交道，所以就会存在阻塞的情况，这个时候就必须用多线程来提速。

业务在线程池内，这里要加锁才行。测试结果2300个/s

测试工具：stressmark

因为加了适用与ab的代码，所以也可以适用ab进行压力测试。

char buf[1000] = {0};
sprintf(buf,"HTTP/1.0 200 OK\r\nContent-type: text/plain\r\n\r\n%s","Hello world!\n");
send(socketfd,buf, strlen(buf),0);

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
 
#include <errno.h>
  
#define MAXLINE 10
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 8006
#define INFTIM 1000
  
//线程池任务队列结构体
 
struct task{
  int fd; //需要读写的文件描述符
 
  struct task *next; //下一个任务
 
};
  
//用于读写两个的两个方面传递参数
 
struct user_data{
  int fd;
  unsigned int n_size;
  char line[MAXLINE];
};
  
//线程的任务函数
 
void * readtask(void *args);
void * writetask(void *args);
  
  
//声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
 
struct epoll_event ev,events[20];
int epfd;
pthread_mutex_t mutex;
pthread_cond_t cond1;
struct task *readhead=NULL,*readtail=NULL,*writehead=NULL;
  
void setnonblocking(int sock)
{
     int opts;
     opts=fcntl(sock,F_GETFL);
     if(opts<0)
     {
          perror("fcntl(sock,GETFL)");
          exit(1);
     }
    opts = opts|O_NONBLOCK;
     if(fcntl(sock,F_SETFL,opts)<0)
     {
          perror("fcntl(sock,SETFL,opts)");
          exit(1);
     } 
}
  
int main()
{
     int i, maxi, listenfd, connfd, sockfd,nfds;
     pthread_t tid1,tid2;
     
     struct task *new_task=NULL;
     struct user_data *rdata=NULL;
     socklen_t clilen;
     
     pthread_mutex_init(&mutex,NULL);
     pthread_cond_init(&cond1,NULL);
     //初始化用于读线程池的线程
 
     pthread_create(&tid1,NULL,readtask,NULL);
     pthread_create(&tid2,NULL,readtask,NULL);
     
     //生成用于处理accept的epoll专用的文件描述符 
 
     epfd=epoll_create(256);
  
     struct sockaddr_in clientaddr;
     struct sockaddr_in serveraddr;
     listenfd = socket(AF_INET, SOCK_STREAM, 0);
     //把socket设置为非阻塞方式
 
     setnonblocking(listenfd);
     //设置与要处理的事件相关的文件描述符
 
     ev.data.fd=listenfd;
     //设置要处理的事件类型
 
     ev.events=EPOLLIN|EPOLLET;
     //注册epoll事件
 
     epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
     
     bzero(&serveraddr, sizeof(serveraddr)); 
     serveraddr.sin_family = AF_INET; 
     serveraddr.sin_port=htons(SERV_PORT);
     serveraddr.sin_addr.s_addr = INADDR_ANY;
     bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
     listen(listenfd, LISTENQ);
     
     maxi = 0;
     for ( ; ; ) {
          //等待epoll事件的发生
 
          nfds=epoll_wait(epfd,events,20,500);
          //处理所发生的所有事件 
 
        for(i=0;i<nfds;++i)
        {
               if(events[i].data.fd==listenfd)
               {
                    
                    connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
                    if(connfd<0){
                      perror("connfd<0");
                      exit(1);
                   }
                    setnonblocking(connfd);
                    
                    char *str = inet_ntoa(clientaddr.sin_addr);
                    //std::cout<<"connec_ from >>"<<str<<std::endl;
 
                    //设置用于读操作的文件描述符
 
                    ev.data.fd=connfd;
                    //设置用于注测的读操作事件
 
                 ev.events=EPOLLIN|EPOLLET;
                    //注册ev
 
                 epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
               }
            else if(events[i].events&EPOLLIN)
            {
                    //printf("reading!/n"); 
 
                    if ( (sockfd = events[i].data.fd) < 0) continue;
                    new_task=new task();
                    new_task->fd=sockfd;
                    new_task->next=NULL;
                    //添加新的读任务
 
                    pthread_mutex_lock(&mutex);
                    if(readhead==NULL)
                    {
                      readhead=new_task;
                      readtail=new_task;
                    } 
                    else
                    { 
                     readtail->next=new_task;
                      readtail=new_task;
                    } 
                   //唤醒所有等待cond1条件的线程
 
                    pthread_cond_broadcast(&cond1);
                    pthread_mutex_unlock(&mutex); 
              }
               else if(events[i].events&EPOLLOUT)
               { 
                 /*
              rdata=(struct user_data *)events[i].data.ptr;
                 sockfd = rdata->fd;
                 write(sockfd, rdata->line, rdata->n_size);
                 delete rdata;
                 //设置用于读操作的文件描述符
                 ev.data.fd=sockfd;
                 //设置用于注测的读操作事件
               ev.events=EPOLLIN|EPOLLET;
                 //修改sockfd上要处理的事件为EPOLIN
               epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
             */
               }
                              
          }
          
     }
}
 
static int count111 = 0;
static time_t oldtime = 0, nowtime = 0;
void * readtask(void *args)
{
    
   int fd=-1;
   unsigned int n;
   //用于把读出来的数据传递出去
 
   struct user_data *data = NULL;
   while(1){
         
        pthread_mutex_lock(&mutex);
        //等待到任务队列不为空
 
        while(readhead==NULL)
             pthread_cond_wait(&cond1,&mutex);
         
        fd=readhead->fd;
        //从任务队列取出一个读任务
 
        struct task *tmp=readhead;
        readhead = readhead->next;
        delete tmp;
        pthread_mutex_unlock(&mutex);
        data = new user_data();
        data->fd=fd;
         
 
        char recvBuf[1024] = {0}; 
        int ret = 999;
        int rs = 1;
 
        while(rs)
        {
            ret = recv(fd,recvBuf,1024,0);// 接受客户端消息
 
            if(ret < 0)
            {
                //由于是非阻塞的模式,所以当errno为EAGAIN时,表示当前缓冲区已无数据可//读在这里就当作是该次事件已处理过。
 
                if(errno == EAGAIN)
                {
                    printf("EAGAIN\n");
                    break;
                }
                else{
                    printf("recv error!\n");
         
                    close(fd);
                    break;
                }
            }
            else if(ret == 0)
            {
                // 这里表示对端的socket已正常关闭. 
 
                rs = 0;
            }
            if(ret == sizeof(recvBuf))
                rs = 1; // 需要再次读取
 
            else
                rs = 0;
        }
        if(ret>0){
 
        //-------------------------------------------------------------------------------
 
 
            data->n_size=n;
 
 
            count111 ++;
 
            struct tm *today;
            time_t ltime;
            time( &nowtime );
 
            if(nowtime != oldtime){
                printf("%d\n", count111);
                oldtime = nowtime;
                count111 = 0;
            }
 
            char buf[1000] = {0};
            sprintf(buf,"HTTP/1.0 200 OK\r\nContent-type: text/plain\r\n\r\n%s","Hello world!\n");
            send(fd,buf,strlen(buf),0);
            close(fd);
 
 
       }
   }
}