Linux线程池
1、半同步 / 半反应堆线程池的实现
这里我们实现了一个半同步 / 半反应堆并发模式的线程池，代码清单见https://github.com/walkerczb/threadpool 中的 threadpool.h 。该线程池使用一个工作队列完全解除了主线程和工作线程的耦合关系：主线程往工作队列中插入任务，工作线程通过竞争来取得任务并执行它。不过，如果要将该线程池应用到实际服务器程序中，那么我们必须保证所有客户请求都是无状态的，因为同一个连接上的不同请求可能会由不同的线程处理。
这里值得一提的是，在 C++ 程序中使用 pthread_create 函数时，该函数的第 3个参数必须指向一个静态函数。而要在一个静态函数中使用类的动态成员（包括成员函数和成员变量），则只能通过如下两种方式实现：
-
通过类的静态对象来调用。
-
将类的对象作为参数传递给该静态函数，然后在静态函数中引入这个对象，并调用其动态方法。
代码清单 threadpool.h 使用的第二种方式：将线程参数设置为 this 指针，然后在worker 函数中获取该指针并调用其动态方法 run 。
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 |
#ifndef THREADPOOL_H
#define THREADPOOL_H #include #include #include #include /*应用第14张介绍的线程同步机制的包装类*/ #include "locker.h" /*线程池类，将它定位为模板是为了代码复用。模板参数T是任务类*/ template< typename T > class threadpool { public: /*参数thread_number是线程池中线程的数量，max_requests是请求队列中最多允许的、 等待处理的请求的数量*/ threadpool( int thread_number = 8, int max_requests = 10000 ); ~threadpool(); /*往请求队列中添加任务*/ bool append( T *request ); private: /*工作线程运行的函数，它不断从工作队列中取出任务并执行之*/ static void *worker( void *arg ); void run(); private: int m_thread_number; /*线程池中的线程数*/ int m_max_requests; /*请求队列中允许的最大请求数*/ pthread_t *m_threads; /*描述线程池的数组，其大小为m_thread_number*/ std::list< T * > m_workqueue; /*请求队列*/ locker m_queuelocker; /*保护请求队列的互斥锁*/ sem m_queuestat; /*是否有任务需要处理*/ bool m_stop; /*是否结束线程*/ }; template< typename T > threadpool< T >::threadpool( int thread_number, int max_requests ) : m_thread_number( thread_number ), m_max_requests( max_requests ), m_stop( false ), m_threads( NULL ) { if( ( thread_number <= 0 ) || ( max_requests <= 0 ) ) { throw std::exception(); } m_threads = new pthread_t[ m_thread_number ]; if( ! m_threads ) { throw std::exception(); } /*创建thread_number个线程，并将它们都设置为脱离线程*/ for ( int i = 0; i < thread_number; ++i ) { printf( "create the %dth thread\n", i ); if( pthread_create( m_threads + i, NULL, worker, this ) != 0 ) { delete [] m_threads; throw std::exception(); } if( pthread_detach( m_threads[i] ) ) { delete [] m_threads; throw std::exception(); } } } template< typename T > threadpool< T >::~threadpool() { delete [] m_threads; m_stop = true; } template< typename T > bool threadpool< T >::append( T *request ) { /*操作工作队列时一定要加锁，因为它被所有线程共享*/ m_queuelocker.lock(); if ( m_workqueue.size() > m_max_requests ) { m_queuelocker.unlock(); return false; } m_workqueue.push_back( request ); m_queuelocker.unlock(); m_queuestat.post(); return true; } template< typename T > void *threadpool< T >::worker( void *arg ) { threadpool *pool = ( threadpool * )arg; pool->run(); return pool; } template< typename T > void threadpool< T >::run() { while ( ! m_stop ) { m_queuestat.wait(); m_queuelocker.lock(); if ( m_workqueue.empty() ) { m_queuelocker.unlock(); continue; } T *request = m_workqueue.front(); m_workqueue.pop_front(); m_queuelocker.unlock(); if ( ! request ) { continue; } request->process(); } } #endif |
2、用线程实现的简单 Web 服务器
这里我们用前面的线程池来实现一个并发的 Web 服务器。
http_conn 类
首先，我们需要准备线程池的模板参数类，用以封装对逻辑任务的处理，这个类是 http_conn ，代码清单见头文件 https://github.com/walkerczb/threadpool 中的 http_conn.h ， http_conn.cpp 和 locker.h 。
http_conn.h
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 |
#ifndef HTTPCONNECTION_H
#define HTTPCONNECTION_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "locker.h" class http_conn { public: /*文件名的最大长度*/ static const int FILENAME_LEN = 200; /*读缓冲区的大小*/ static const int READ_BUFFER_SIZE = 2048; /*写缓冲区的大小*/ static const int WRITE_BUFFER_SIZE = 1024; /*HTTP请求方法，但我们进支持GET*/ enum METHOD { GET = 0, POST, HEAD, PUT, DELETE, TRACE, OPTIONS, CONNECT, PATCH }; /*解析客户请求时，主状态机所处的状态*/ enum CHECK_STATE { CHECK_STATE_REQUESTLINE = 0, CHECK_STATE_HEADER, CHECK_STATE_CONTENT }; /*服务器处理HTTP请求时的可能结果*/ enum HTTP_CODE { NO_REQUEST, GET_REQUEST, BAD_REQUEST, NO_RESOURCE, FORBIDDEN_REQUEST, FILE_REQUEST, INTERNAL_ERROR, CLOSED_CONNECTION }; /*行的读取状态*/ enum LINE_STATUS { LINE_OK = 0, LINE_BAD, LINE_OPEN }; public: http_conn() {} ~http_conn() {} public: /*初始化新接手的连接*/ void init( int sockfd, const sockaddr_in &addr ); /*关闭连接*/ void close_conn( bool real_close = true ); /*处理客户请求*/ void process(); /*非阻塞读操作*/ bool read(); /*非阻塞写操作*/ bool write(); private: /*初始化连接*/ void init(); /*解析HTTP请求*/ HTTP_CODE process_read(); /*填充HTPTP应答*/ bool process_write( HTTP_CODE ret ); /*下面这一组函数被process_read调用以分析HTTP请求*/ HTTP_CODE parse_request_line( char *text ); HTTP_CODE parse_headers( char *text ); HTTP_CODE parse_content( char *text ); HTTP_CODE do_request(); char *get_line() { return m_read_buf + m_start_line; } LINE_STATUS parse_line(); /*下面这一组函数被process_write调用以填充HTTP应答*/ void unmap(); bool add_response( const char *format, ... ); bool add_content( const char *content ); bool add_status_line( int status, const char *title ); bool add_headers( int content_length ); bool add_content_length( int content_length ); bool add_linger(); bool add_blank_line(); public: /*所有socket上的事件都被注册到同一个epoll内核事件上，所有将epoll文件描述符设置为静态的*/ static int m_epollfd; /*统计用户数量*/ static int m_user_count; private: /*读HTTP连接的socket和对方的socket地址*/ int m_sockfd; sockaddr_in m_address; /*读缓冲区*/ char m_read_buf[ READ_BUFFER_SIZE ]; /*标识读缓冲区中已经读入的客户数据的最后一个字节的下一个位置*/ int m_read_idx; /*当前正在分析的字符在读缓冲区中的位置*/ int m_checked_idx; /*当前正在解析的行的起始位置*/ int m_start_line; /*写缓冲区*/ char m_write_buf[ WRITE_BUFFER_SIZE ]; /*写缓冲区中待发送的字节数*/ int m_write_idx; /*主状态机当前所处的状态*/ CHECK_STATE m_check_state; /*请求方法*/ METHOD m_method; /*客户请求的目标文件的完整路径，其内容等于doc_toot+m_url,doc_root是网站跟目录*/ char m_real_file[ FILENAME_LEN ]; /*客户请求的目标文件名*/ char *m_url; /*HTTP协议版本号，我们进支持HTTP/1.1*/ char *m_version; /*主机名*/ char *m_host; /*HTTP请求的消息体的长度*/ int m_content_length; /*HTTP请求是否要求保持连接*/ bool m_linger; /*客户请求的目标文件被mmap到内存中的起始位置*/ char *m_file_address; /*目标文件的状态。通过它我们可以判断文件是否存在、是否为目录、是否可读，并获取文件大小等信息*/ struct stat m_file_stat; /*我们将采取writev来执行写操作，所以定义下面两个成员，其中m_iv_count表示被写内存块的数量*/ struct iovec m_iv[ 2]; int m_iv_count; }; #endif |
http_conn.cpp
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 |
#include
"http_conn.h"
/*定义HTTP相应的一些状态信息*/ const char *ok_200_title = "OK"; const char *error_400_title = "Bad Request"; const char *error_400_form = "Your request has bad syntax or is inherently impossible to satisfy.\n"; const char *error_403_title = "Forbidden"; const char *error_403_form = "You do not have permission to get file from this server.\n"; const char *error_404_title = "Not Found"; const char *error_404_form = "The requested file was not found on this server.\n"; const char *error_500_title = "Internal Error"; const char *error_500_form = "There was an unusual problem serving the requested file.\n"; /*网站根目录*/ const char *doc_root = "/var/www/html"; int setnonblocking( int fd ) { int old_option = fcntl( fd, F_GETFL ); int new_option = old_option | O_NONBLOCK; fcntl( fd, F_SETFL, new_option ); return old_option; } void addfd( int epollfd, int fd, bool one_shot ) { epoll_event event; event.data.fd = fd; event.events = EPOLLIN | EPOLLET | EPOLLRDHUP; if( one_shot ) { event.events |= EPOLLONESHOT; } epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event ); setnonblocking( fd ); } void removefd( int epollfd, int fd ) { epoll_ctl( epollfd, EPOLL_CTL_DEL, fd, 0 ); close( fd ); } void modfd( int epollfd, int fd, int ev ) { epoll_event event; event.data.fd = fd; event.events = ev | EPOLLET | EPOLLONESHOT | EPOLLRDHUP; epoll_ctl( epollfd, EPOLL_CTL_MOD, fd, &event ); } int http_conn::m_user_count = 0; int http_conn::m_epollfd = - 1; void http_conn::close_conn( bool real_close ) { if( real_close && ( m_sockfd != - 1 ) ) { //modfd( m_epollfd, m_sockfd, EPOLLIN ); removefd( m_epollfd, m_sockfd ); m_sockfd = - 1; m_user_count--; } } void http_conn::init( int sockfd, const sockaddr_in &addr ) { m_sockfd = sockfd; m_address = addr; int error = 0; socklen_t len = sizeof( error ); getsockopt( m_sockfd, SOL_SOCKET, SO_ERROR, &error, &len ); /*以下两行是为了避免TIME_WAIT状态，仅用于调试，实际使用时应该去掉*/ int reuse = 1; setsockopt( m_sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof( reuse ) ); addfd( m_epollfd, sockfd, true ); m_user_count++; init(); } void http_conn::init() { m_check_state = CHECK_STATE_REQUESTLINE; m_linger = false; m_method = GET; m_url = 0; m_version = 0; m_content_length = 0; m_host = 0; m_start_line = 0; m_checked_idx = 0; m_read_idx = 0; m_write_idx = 0; memset( m_read_buf, '\0', READ_BUFFER_SIZE ); memset( m_write_buf, '\0', WRITE_BUFFER_SIZE ); memset( m_real_file, '\0', FILENAME_LEN ); } /*从状态机*/ http_conn::LINE_STATUS http_conn::parse_line() { char temp; /*m_checked_index指向m_read_buf中当前正在分析的字节，m_read_idx指向m_read_buffer中客户数据的 尾部的下一字节。m_read_buffer中第0~m_checked_index字节都已经分析完毕，第m_checked_index~（m_read_index-1） 字节由下面的循环挨个分析*/ for ( ; m_checked_idx < m_read_idx; ++m_checked_idx ) { /*获得当前要分析的字节*/ temp = m_read_buf[ m_checked_idx ]; /*如果当前的字节是"\r"，即回车符，则说明可能读取到一个完整的行*/ if ( temp == '\r' ) { /*如果“\r”字符碰巧是目前m_read_buffer中最后一个已经被读入的客户数据，那么这次分析 没有读取到一个完整的行，返回LINE_OPEN以表示还需要继续去客户数据才能进一步分析*/ if ( ( m_checked_idx + 1 ) == m_read_idx ) { return LINE_OPEN; } /*如果下一个字符时"\n"，则说明我们成功读取一个完整的行*/ else if ( m_read_buf[ m_checked_idx + 1 ] == '\n' ) { m_read_buf[ m_checked_idx++ ] = '\0'; m_read_buf[ m_checked_idx++ ] = '\0'; return LINE_OK; } /*否则的话，说明客户发送的HTTP请求存在语法问题*/ return LINE_BAD; } /*如果当前的字节是"\n"，即换行符，则也说明可能读取到一个完整的行*/ else if( temp == '\n' ) { if( ( m_checked_idx > 1 ) && ( m_read_buf[ m_checked_idx - 1 ] == '\r' ) ) { m_read_buf[ m_checked_idx - 1 ] = '\0'; m_read_buf[ m_checked_idx++ ] = '\0'; return LINE_OK; } return LINE_BAD; } } /*如果所有内容都分析完毕也没有遇到"\r"字符，则返回LINE_OPEN，表示还需要继续读取客户数据才能进一步分析*/ return LINE_OPEN; } /*循环读取客户数据，直到无数据可读或者对方关闭连接*/ bool http_conn::read() { if( m_read_idx >= READ_BUFFER_SIZE ) { return false; } int bytes_read = 0; while( true ) { bytes_read = recv( m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0 ); if ( bytes_read == - 1 ) { if( errno == EAGAIN || errno == EWOULDBLOCK ) { break; } return false; } else if ( bytes_read == 0 ) { return false; } m_read_idx += bytes_read; } return true; } /*解析HTTP请求行，获得请求方法、目标URL，以及HTTP版本号*/ http_conn::HTTP_CODE http_conn::parse_request_line( char *text ) { m_url = strpbrk( text, " \t" ); /*如果请求行中没有空白字符或“\t”，则HTTP请求必有问题*/ if ( ! m_url ) { return BAD_REQUEST; } *m_url++ = '\0'; char *method = text; if ( strcasecmp( method, "GET" ) == 0 ) { m_method = GET; } else { return BAD_REQUEST; } m_url += strspn( m_url, " \t" ); m_version = strpbrk( m_url, " \t" ); if ( ! m_version ) { return BAD_REQUEST; } *m_version++ = '\0'; m_version += strspn( m_version, " \t" ); /*仅支持HTTP/1.1*/ if ( strcasecmp( m_version, "HTTP/1.1" ) != 0 ) { return BAD_REQUEST; } /*检查URL是否合法*/ if ( strncasecmp( m_url, "http://", 7 ) == 0 ) { m_url += 7; m_url = strchr( m_url, '/' ); } if ( ! m_url || m_url[ 0 ] != '/' ) { return BAD_REQUEST; } /*HTTP请求行处理完毕，状态转移到头部字段的分析*/ m_check_state = CHECK_STATE_HEADER; return NO_REQUEST; } /*解析HTTP请求的一个头部信息*/ http_conn::HTTP_CODE http_conn::parse_headers( char *text ) { /*遇到空行，表示头部字段解析完毕*/ if( text[ 0 ] == '\0' ) { if ( m_method == HEAD ) { return GET_REQUEST; } /*如果HTTP请求有消息体，则还需要读取m_content_length字节的小西天， 状态机转移到CHECK_STATE_CONTENT状态*/ if ( m_content_length != 0 ) { m_check_state = CHECK_STATE_CONTENT; return NO_REQUEST; } /*否则说明我们已经得到了一个完整的HTTP请求*/ return GET_REQUEST; } /*处理Connection头部字段*/ else if ( strncasecmp( text, "Connection:", 11 ) == 0 ) { text += 11; text += strspn( text, " \t" ); if ( strcasecmp( text, "keep-alive" ) == 0 ) { m_linger = true; } } /*处理Content-Length头部字段*/ else if ( strncasecmp( text, "Content-Length:", 15 ) == 0 ) { text += 15; text += strspn( text, " \t" ); m_content_length = atol( text ); } /*处理Host头部字段*/ else if ( strncasecmp( text, "Host:", 5 ) == 0 ) { text += 5; text += strspn( text, " \t" ); m_host = text; } else { printf( "oop! unknow header %s\n", text ); } return NO_REQUEST; } /*我们没有真正解析HTTP请求的消息体，只是判断它是否被完整的读入了*/ http_conn::HTTP_CODE http_conn::parse_content( char *text ) { if ( m_read_idx >= ( m_content_length + m_checked_idx ) ) { text[ m_content_length ] = '\0'; return GET_REQUEST; } return NO_REQUEST; } /*主状态机出*/ http_conn::HTTP_CODE http_conn::process_read() { LINE_STATUS line_status = LINE_OK; /*记录当前的读取状态*/ HTTP_CODE ret = NO_REQUEST; /*记录HTTP请求的处理结果*/ char *text = 0; /*用于从m_read_buffer中取出完整的行*/ while ( ( ( m_check_state == CHECK_STATE_CONTENT ) && ( line_status == LINE_OK ) ) || ( ( line_status = parse_line() ) == LINE_OK ) ) { text = get_line(); m_start_line = m_checked_idx; /*记录下一行的其实位置*/ printf( "got 1 http line: %s\n", text ); switch ( m_check_state ) { case CHECK_STATE_REQUESTLINE: /*第一个状态，分析请求*/ { ret = parse_request_line( text ); if ( ret == BAD_REQUEST ) { return BAD_REQUEST; } break; } case CHECK_STATE_HEADER: /*第二个状态，分析头部字段*/ { ret = parse_headers( text ); if ( ret == BAD_REQUEST ) { return BAD_REQUEST; } else if ( ret == GET_REQUEST ) { return do_request(); } break; } case CHECK_STATE_CONTENT: /*第三个状态，分析请求包体*/ { ret = parse_content( text ); if ( ret == GET_REQUEST ) { return do_request(); } line_status = LINE_OPEN; break; } default: { return INTERNAL_ERROR; } } } return NO_REQUEST; } /*当得到一个完整、正确的HTTP请求时，我们就分析目标文件的属性。如果目标文件存在、 对所有用户可读、且不是目录，则使用mmap将其映射到内存地址m_file_address处，并告诉 调用者获取文件成功*/ http_conn::HTTP_CODE http_conn::do_request() { strcpy( m_real_file, doc_root ); int len = strlen( doc_root ); strncpy( m_real_file + len, m_url, FILENAME_LEN - len - 1 ); if ( stat( m_real_file, &m_file_stat ) < 0 ) { return NO_RESOURCE; } if ( ! ( m_file_stat.st_mode & S_IROTH ) ) { return FORBIDDEN_REQUEST; } if ( S_ISDIR( m_file_stat.st_mode ) ) { return BAD_REQUEST; } int fd = open( m_real_file, O_RDONLY ); m_file_address = ( char * )mmap( 0, m_file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0 ); close( fd ); return FILE_REQUEST; } /*对内存映射去执行munmap操作*/ void http_conn::unmap() { if( m_file_address ) { munmap( m_file_address, m_file_stat.st_size ); m_file_address = 0; } } /*写HTTP响应*/ bool http_conn::write() { int temp = 0; int bytes_have_send = 0; int bytes_to_send = m_write_idx; if ( bytes_to_send == 0 ) { modfd( m_epollfd, m_sockfd, EPOLLIN ); init(); return true; } while( 1 ) { temp = writev( m_sockfd, m_iv, m_iv_count ); if ( temp <= - 1 ) { /*如果TCP写缓冲区没有空间，则等待下一轮EPOLLOUT事件。虽然在此期间，服务器无法立即接收到 同一客户的下一个请求，但这可以保证连接的完整性*/ if( errno == EAGAIN ) { modfd( m_epollfd, m_sockfd, EPOLLOUT ); return true; } /*发送HTTP响应成功，根据HTTP请求中的Connection字段决定是否立即关闭连接*/ unmap(); return false; } bytes_to_send -= temp; bytes_have_send += temp; if ( bytes_to_send <= bytes_have_send ) { unmap(); if( m_linger ) { init(); modfd( m_epollfd, m_sockfd, EPOLLIN ); return true; } else { modfd( m_epollfd, m_sockfd, EPOLLIN ); return false; } } } } /*往写缓冲区写入待发送的数据*/ bool http_conn::add_response( const char *format, ... ) { if( m_write_idx >= WRITE_BUFFER_SIZE ) { return false; } va_list arg_list; va_start( arg_list, format ); int len = vsnprintf( m_write_buf + m_write_idx, WRITE_BUFFER_SIZE - 1 - m_write_idx, format, arg_list ); if( len >= ( WRITE_BUFFER_SIZE - 1 - m_write_idx ) ) { return false; } m_write_idx += len; va_end( arg_list ); return true; } bool http_conn::add_status_line( int status, const char *title ) { return add_response( "%s %d %s\r\n", "HTTP/1.1", status, title ); } bool http_conn::add_headers( int content_len ) { add_content_length( content_len ); add_linger(); add_blank_line(); } bool http_conn::add_content_length( int content_len ) { return add_response( "Content-Length: %d\r\n", content_len ); } bool http_conn::add_linger() { return add_response( "Connection: %s\r\n", ( m_linger == true ) ? "keep-alive" : "close" ); } bool http_conn::add_blank_line() { return add_response( "%s", "\r\n" ); } bool http_conn::add_content( const char *content ) { return add_response( "%s", content ); } /*根据服务器处理HTTP请求的结果，决定返回给客户端的内容*/ bool http_conn::process_write( HTTP_CODE ret ) { switch ( ret ) { case INTERNAL_ERROR: { add_status_line( 500, error_500_title ); add_headers( strlen( error_500_form ) ); if ( ! add_content( error_500_form ) ) { return false; } break; } case BAD_REQUEST: { add_status_line( 400, error_400_title ); add_headers( strlen( error_400_form ) ); if ( ! add_content( error_400_form ) ) { return false; } break; } case NO_RESOURCE: { add_status_line( 404, error_404_title ); add_headers( strlen( error_404_form ) ); if ( ! add_content( error_404_form ) ) { return false; } break; } case FORBIDDEN_REQUEST: { add_status_line( 403, error_403_title ); add_headers( strlen( error_403_form ) ); if ( ! add_content( error_403_form ) ) { return false; } break; } case FILE_REQUEST: { add_status_line( 200, ok_200_title ); if ( m_file_stat.st_size != 0 ) { add_headers( m_file_stat.st_size ); m_iv[ 0 ].iov_base = m_write_buf; m_iv[ 0 ].iov_len = m_write_idx; m_iv[ 1 ].iov_base = m_file_address; m_iv[ 1 ].iov_len = m_file_stat.st_size; m_iv_count = 2; return true; } else { const char *ok_string = ""; add_headers( strlen( ok_string ) ); if ( ! add_content( ok_string ) ) { return false; } } } default: { return false; } } m_iv[ 0 ].iov_base = m_write_buf; m_iv[ 0 ].iov_len = m_write_idx; m_iv_count = 1; return true; } /*由线程中的工作线程调用，这是处理HTTP请求的入口函数*/ void http_conn::process() { HTTP_CODE read_ret = process_read(); if ( read_ret == NO_REQUEST ) { modfd( m_epollfd, m_sockfd, EPOLLIN ); return; } bool write_ret = process_write( read_ret ); if ( ! write_ret ) { close_conn(); } modfd( m_epollfd, m_sockfd, EPOLLOUT ); } |
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
#ifndef LOCKER_H
#define LOCKER_H #include #include #include class sem { public: /*封装信号量的类*/ sem() { if( sem_init( &m_sem, 0, 0 ) != 0 ) { /*构造函数没有返回值，可以通过抛出异常来报告错误*/ throw std::exception(); } } /*销毁信号量*/ ~sem() { sem_destroy( &m_sem ); } /*等待信号量*/ bool wait() { return sem_wait( &m_sem ) == 0; } /*增加信号量*/ bool post() { return sem_post( &m_sem ) == 0; } private: sem_t m_sem; }; /*封装互斥锁的类*/ class locker { public: /*创建并初始化互斥锁*/ locker() { if( pthread_mutex_init( &m_mutex, NULL ) != 0 ) { throw std::exception(); } } /*销毁互斥锁*/ ~locker() { pthread_mutex_destroy( &m_mutex ); } /*获取互斥锁*/ bool lock() { return pthread_mutex_lock( &m_mutex ) == 0; } /*释放互斥锁*/ bool unlock() { return pthread_mutex_unlock( &m_mutex ) == 0; } private: pthread_mutex_t m_mutex; }; /*封装条件变量*/ class cond { public: /*创建并初始化条件变量*/ cond() { if( pthread_mutex_init( &m_mutex, NULL ) != 0 ) { throw std::exception(); } if ( pthread_cond_init( &m_cond, NULL ) != 0 ) { pthread_mutex_destroy( &m_mutex ); throw std::exception(); } } /*销毁条件变量*/ ~cond() { pthread_mutex_destroy( &m_mutex ); pthread_cond_destroy( &m_cond ); } /*等待条件变量*/ bool wait() { int ret = 0; pthread_mutex_lock( &m_mutex ); ret = pthread_cond_wait( &m_cond, &m_mutex ); pthread_mutex_unlock( &m_mutex ); return ret == 0; } /*唤醒等待条件变量的线程*/ bool signal() { return pthread_cond_signal( &m_cond ) == 0; } private: pthread_mutex_t m_mutex; pthread_cond_t m_cond; }; #endif |
main函数的实现
定义好任务之后， main 函数就变得很简单了，它只需要负责 I/O 读写，如代码清单 https://github.com/walkerczb/threadpool 中的 main.cpp 。
C++ Code
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 |
#include #include #include #include #include #include #include #include #include #include #include #include "locker.h" #include "threadpool.h" #include "http_conn.h" #define MAX_FD 65536 #define MAX_EVENT_NUMBER 10000 extern int addfd( int epollfd, int fd, bool one_shot ); extern int removefd( int epollfd, int fd ); void addsig( int sig, void( handler )( int), bool restart = true ) { struct sigaction sa; memset( &sa, '\0', sizeof( sa ) ); sa.sa_handler = handler; if( restart ) { sa.sa_flags |= SA_RESTART; } sigfillset( &sa.sa_mask ); assert( sigaction( sig, &sa, NULL ) != - 1 ); } void show_error( int connfd, const char *info ) { printf( "%s", info ); send( connfd, info, strlen( info ), 0 ); close( connfd ); } int main( int argc, char *argv[] ) { if( argc <= 2 ) { printf( "usage: %s ip_address port_number\n", basename( argv[ 0] ) ); return 1; } const char *ip = argv[ 1]; int port = atoi( argv[ 2] ); /*忽略SIGPIPE信号*/ addsig( SIGPIPE, SIG_IGN ); threadpool< http_conn > *pool = NULL; try { pool = new threadpool< http_conn >; } catch( ... ) { return 1; } /*预先为每个可能的客户连接分配一个http_conn对象*/ http_conn *users = new http_conn[ MAX_FD ]; assert( users ); int user_count = 0; int listenfd = socket( PF_INET, SOCK_STREAM, 0 ); assert( listenfd >= 0 ); struct linger tmp = { 1, 0 }; setsockopt( listenfd, SOL_SOCKET, SO_LINGER, &tmp, sizeof( tmp ) ); int ret = 0; struct sockaddr_in address; bzero( &address, sizeof( address ) ); address.sin_family = AF_INET; inet_pton( AF_INET, ip, &address.sin_addr ); address.sin_port = htons( port ); ret = bind( listenfd, ( struct sockaddr * )&address, sizeof( address ) ); assert( ret >= 0 ); ret = listen( listenfd, 5 ); assert( ret >= 0 ); epoll_event events[ MAX_EVENT_NUMBER ]; int epollfd = epoll_create( 5 ); assert( epollfd != - 1 ); addfd( epollfd, listenfd, false ); http_conn::m_epollfd = epollfd; while( true ) { int number = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, - 1 ); if ( ( number < 0 ) && ( errno != EINTR ) ) { printf( "epoll failure\n" ); break; } for ( int i = 0; i < number; i++ ) { int sockfd = events[i].data.fd; if( sockfd == listenfd ) { struct sockaddr_in client_address; socklen_t client_addrlength = sizeof( client_address ); int connfd = accept( listenfd, ( struct sockaddr * )&client_address, &client_addrlength ); if ( connfd < 0 ) { printf( "errno is: %d\n", errno ); continue; } if( http_conn::m_user_count >= MAX_FD ) { show_error( connfd, "Internal server busy" ); continue; } /*初始化客户连接*/ users[connfd].init( connfd, client_address ); } else if( events[i].events & ( EPOLLRDHUP | EPOLLHUP | EPOLLERR ) ) { /*如果有异常，直接关闭客户连接*/ users[sockfd].close_conn(); } else if( events[i].events & EPOLLIN ) { /*根据读的结果，决定是将任务添加到线程池还是关闭连接*/ if( users[sockfd].read() ) { pool->append( users + sockfd ); } else { users[sockfd].close_conn(); } } else if( events[i].events & EPOLLOUT ) { /*根据写的结果，决定是否关闭连接*/ if( !users[sockfd].write() ) { users[sockfd].close_conn(); } } else {} } } close( epollfd ); close( listenfd ); delete [] users; delete pool; return 0; } |