最近在尝试自己写一个Http服务器，在粗略研究了nginx的代码之后，决定仿照nginx中的部分设计自己实现一个高并发的HTTP服务器，在这里分享给大家。
目前使用的较多的Http服务器就是apache和nginx，apache的主要特点就是稳定，而nginx的主要特点是承载的并发量高。在这里从实现原理上做一个分析：
apache采用的是多进程服务器模型，即服务器每监听到一个连接时，会创建一个新的进程去处理连接，进程与进程之间是独立的，因此就算进程在处理连接的过程中崩溃了，也不会影响其他进程的运行。但由于服务器能创建的进程数目与内存有关，因此服务器的最大并发数会受到机器内存的影响，同时如果有人发起大量恶意长链接攻击，就会导致服务器超载。
nginx采用的是多路IO复用服务器模型，即服务器每监听到一个连接时，会将连接加入到连接数组中，使用epoll多路IO复用函数对每个连接进行监听，当连接中有数据到来时，epoll会返回相应的连接，依此对各个连接进行处理即可。epoll的最大连接数量虽然也会受到内存的影响，但由于每个未激活的连接占用的内存很小，所以相比于apache可以承载更大的并发。
但由于多路IO复用是在一个进程中进行的，所以如果在处理连接的过程中崩溃了，其他连接也会受到影响。为了解决这个问题，nginx中也引入了多进程，即nginx服务器由一个master进程和多个worker进程组成。master进程作为父进程在启动的时候会创建socket套接字以及若干个worker进程，每个worker进程会使用epoll对master创建的套接字进行监听。当有新连接到来时，若干个worker进程的epoll函数都会返回，但只有一个worker进程可以accept成功。该进程accept成功之后将该连接加入到epoll的监听数组中，该连接之后的数据都将由该worker进程处理。如果其中一个worker进程在处理连接的过程中崩溃了，父进程会收到信号并重启该进程以保证服务器的稳定性。
另外，每次新连接到来都会唤醒若干个worker进程同时进行accept，但只有一个worker能accept成功，为了避免这个问题，nginx引入了互斥信号量，即每个worker进程在accept之前都需要先获取锁，如果获取不到则放弃accept。
在明确了上述原理之后，我们就可以仿照nginx实现一个http服务器了。首先是创建套接字的函数：
//创建socket
int startup(int port) {
struct sockaddr_in servAddr;
memset(&servAddr, 0, sizeof(servAddr));
//协议域（ip地址和端口）
servAddr.sin_family = AF_INET;
//绑定默认网卡
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
//端口
servAddr.sin_port = htons(port);
int listenFd;
//创建套接字
if ((listenFd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
return 0;
}
unsigned value = 1;
setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value));
//绑定套接字
if (bind(listenFd, (struct sockaddr *)&servAddr, sizeof(servAddr))) {
printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
return 0;
}
//开始监听，设置最大连接请求
if (listen(listenFd, 10) == -1) {
printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
return 0;
}
return listenFd;
}//管理子进程的数组，数组多大就有几个子进程
static int processArr[PROCESS_NUM];
//创建若干个子进程，返回当前进程是否父进程
bool createSubProcess() {
for (int i=0; i<GET_ARRAY_LEN(processArr); i++) {
int pid = fork();
//如果是子进程，返回0
if (pid == 0) {
return false;
}
//如果是父进程，继续fork
else if (pid >0){
processArr[i] = pid;
continue;
}
//如果出错
else {
fprintf(stderr,"can‘t fork ,error %d\n",errno);
return true;
}
}
return true;
}//信号处理
void handleTerminate(int signal) {
for (int i=0; i<GET_ARRAY_LEN(processArr); i++) {
kill(processArr[i], SIGTERM);
}
exit(0);
}int main(int argc, const char * argv[])
{
int listenFd;
initMutex();
//设置端口号
listenFd = startup(8080);
//创建若干个子进程
bool isParent = createSubProcess();
//如果是父进程
if (isParent) {
while (1) {
//注册信号处理
signal(SIGTERM, handleTerminate);
//挂起等待信号
pause();
}
}
//如果是子进程
else {
//套接字集合
fd_set rset;
//最大套接字
int maxFd = listenFd;
std::set<int> fdArray;
//循环处理事件
while (1) {
FD_ZERO(&rset);
FD_SET(listenFd, &rset);
//重新设置每个需要监听的套接字
for (std::set<int>::iterator iterator=fdArray.begin();iterator!=fdArray.end();iterator++) {
FD_SET(*iterator, &rset);
}
//开始监听
if (select(maxFd+1, &rset, NULL, NULL, NULL)<0) {
fprintf(stderr, "select error: %s(errno: %d)\n",strerror(errno),errno);
continue;
}
//遍历每个连接套接字
for (std::set<int>::iterator iterator=fdArray.begin();iterator!=fdArray.end();) {
int currentFd = *iterator;
if (FD_ISSET(currentFd, &rset)) {
if (!handleRequest(currentFd)) {
close(currentFd);
fdArray.erase(iterator++);
continue;
}
}
++iterator;
}
//检查连接监听套接字
if (FD_ISSET(listenFd, &rset)) {
if (pthread_mutex_trylock(mutex)==0) {
int newFd = accept(listenFd, (struct sockaddr *)NULL, NULL);
if (newFd<=0) {
fprintf(stderr, "accept socket error: %s(errno: %d)\n",strerror(errno),errno);
continue;
}
//更新最大的套接字
if (newFd>maxFd) {
maxFd = newFd;
}
fdArray.insert(newFd);
pthread_mutex_unlock(mutex);
}
}
}
}
close(listenFd);
return 0;
}//互斥量
pthread_mutex_t *mutex;
//创建共享的mutex
void initMutex()
{
//设置互斥量为进程间共享
mutex=(pthread_mutex_t*)mmap(NULL, sizeof(pthread_mutex_t), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
if( MAP_FAILED==mutex) {
perror("mutex mmap failed");
exit(1);
}
//设置attr的属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
int ret = pthread_mutexattr_setpshared(&attr,PTHREAD_PROCESS_SHARED);
if(ret != 0) {
fprintf(stderr, "mutex set shared failed");
exit(1);
}
pthread_mutex_init(mutex, &attr);
}//处理http请求
bool handleRequest(int connFd) {
if (connFd<=0) return false;
//读取缓存
char buff[4096];
//读取http header
int len = (int)recv(connFd, buff, sizeof(buff), 0);
if (len<=0) {
return false;
}
buff[len] = ‘\0‘;
std::cout<<buff<<std::endl;
return true;
}#include <iostream>
#include <set>
#include <signal.h>
#include <sys/select.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <pthread.h>
#define GET_ARRAY_LEN(array) (sizeof(array) / sizeof(array[0]))
#define PROCESS_NUM 4
//创建socket
int startup(int port) {
struct sockaddr_in servAddr;
memset(&servAddr, 0, sizeof(servAddr));
//协议域（ip地址和端口）
servAddr.sin_family = AF_INET;
//绑定默认网卡
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
//端口
servAddr.sin_port = htons(port);
int listenFd;
//创建套接字
if ((listenFd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
return 0;
}
unsigned value = 1;
setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value));
//绑定套接字
if (bind(listenFd, (struct sockaddr *)&servAddr, sizeof(servAddr))) {
printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
return 0;
}
//开始监听，设置最大连接请求
if (listen(listenFd, 10) == -1) {
printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
return 0;
}
return listenFd;
}
//管理子进程的数组，数组多大就有几个子进程
static int processArr[PROCESS_NUM];
//创建若干个子进程，返回当前进程是否父进程
bool createSubProcess() {
for (int i=0; i<GET_ARRAY_LEN(processArr); i++) {
int pid = fork();
//如果是子进程，返回0
if (pid == 0) {
return false;
}
//如果是父进程，继续fork
else if (pid >0){
processArr[i] = pid;
continue;
}
//如果出错
else {
fprintf(stderr,"can‘t fork ,error %d\n",errno);
return true;
}
}
return true;
}
//信号处理
void handleTerminate(int signal) {
for (int i=0; i<GET_ARRAY_LEN(processArr); i++) {
kill(processArr[i], SIGTERM);
}
exit(0);
}
//处理http请求
bool handleRequest(int connFd) {
if (connFd<=0) return false;
//读取缓存
char buff[4096];
//读取http header
int len = (int)recv(connFd, buff, sizeof(buff), 0);
if (len<=0) {
return false;
}
buff[len] = ‘\0‘;
std::cout<<buff<<std::endl;
return true;
}
//互斥量
pthread_mutex_t *mutex;
//创建共享的mutex
void initMutex()
{
//设置互斥量为进程间共享
mutex=(pthread_mutex_t*)mmap(NULL, sizeof(pthread_mutex_t), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
if( MAP_FAILED==mutex) {
perror("mutex mmap failed");
exit(1);
}
//设置attr的属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
int ret = pthread_mutexattr_setpshared(&attr,PTHREAD_PROCESS_SHARED);
if(ret != 0) {
fprintf(stderr, "mutex set shared failed");
exit(1);
}
pthread_mutex_init(mutex, &attr);
}
int main(int argc, const char * argv[])
{
int listenFd;
initMutex();
//设置端口号
listenFd = startup(8080);
//创建若干个子进程
bool isParent = createSubProcess();
//如果是父进程
if (isParent) {
while (1) {
//注册信号处理
signal(SIGTERM, handleTerminate);
//挂起等待信号
pause();
}
}
//如果是子进程
else {
//套接字集合
fd_set rset;
//最大套接字
int maxFd = listenFd;
std::set<int> fdArray;
//循环处理事件
while (1) {
FD_ZERO(&rset);
FD_SET(listenFd, &rset);
//重新设置每个需要监听的套接字
for (std::set<int>::iterator iterator=fdArray.begin();iterator!=fdArray.end();iterator++) {
FD_SET(*iterator, &rset);
}
//开始监听
if (select(maxFd+1, &rset, NULL, NULL, NULL)<0) {
fprintf(stderr, "select error: %s(errno: %d)\n",strerror(errno),errno);
continue;
}
//遍历每个连接套接字
for (std::set<int>::iterator iterator=fdArray.begin();iterator!=fdArray.end();) {
int currentFd = *iterator;
if (FD_ISSET(currentFd, &rset)) {
if (!handleRequest(currentFd)) {
close(currentFd);
fdArray.erase(iterator++);
continue;
}
}
++iterator;
}
//检查连接监听套接字
if (FD_ISSET(listenFd, &rset)) {
if (pthread_mutex_trylock(mutex)==0) {
int newFd = accept(listenFd, (struct sockaddr *)NULL, NULL);
if (newFd<=0) {
fprintf(stderr, "accept socket error: %s(errno: %d)\n",strerror(errno),errno);
continue;
}
//更新最大的套接字
if (newFd>maxFd) {
maxFd = newFd;
}
fdArray.insert(newFd);
pthread_mutex_unlock(mutex);
}
}
}
}
close(listenFd);
return 0;
}
下一篇文章《仿nginx Http服务器的设计与实现（二）——http协议解析》中，将向大家说明如何对http协议进行解析。
仿nginx Http服务器的设计与实现（一）——多进程和多路IO的实现
原文地址：http://blog.csdn.net/zhaoxy_thu/article/details/24624729
