从零开始自制实现WebServer（二）---- 勿在浮沙筑高层摸谈初试进程/线程池与高效并发模型

Love 6

已于 2022-04-24 19:00:52 修改

阅读量4.2k

点赞数 8

分类专栏：从WebServer开始的进步之路 # 从零开始自制WebServer 文章标签： linux 后端服务器

于 2022-03-17 12:03:37 首次发布

本文链接：https://blog.csdn.net/qq_37500516/article/details/123509817

版权

从WebServer开始的进步之路同时被 2 个专栏收录

25 篇文章 87 订阅

订阅专栏

从零开始自制WebServer

25 篇文章 21 订阅

订阅专栏

文章目录

全流程实现博客链接

从零开始自制实现C++ High-Performance WebServer 全流程记录（基于muduo网络库）

前引

话说上一章节谈到了我们用了单线程Epoll + non_blocking 做了个简易的echo server 我们还没有摸到多线程/多进程的坎呢

其实多线程多进程也无非就是 pthread_creater/fork而已但是需要考虑的东西也就更多了例如临界区/竞态条件了 race condition 考虑到这个又要用一些进程间的通信原语去解决问题了例如mutex cond/pipe sig shm 然后使用这些又需要注意很多地方死锁/临界区一些内存已经不存在而在其他线程中要被使用

上面也只不过是聊到了冰山一角为了充分利用cpu中的多核所以尽管困难重重但是为了性能这种任务还是交给感性的人来做是更好的所以在这里个人认为机器在短时间之内想要完全替代人类还是不太可能的毕竟像各种临界区冲突情况这么复杂的分析我觉得也只有有经验的老程序员或者真的认真思考过的才能够比较好的写出没有什么冲突的代码

好了就先写到这里啦我继续去看看后面的进/线程池代码源码然后凭借着印象自己一点一点鼓捣出来吧

刚刚忽然看到自己的第一篇这个系列博客的名字万丈高楼平地起哈哈当时写的时候真的是随意写的
之后这第二篇我是真的忽然想到一句勿在浮沙筑高楼因为第一篇我们只不是在为后面的一步步做基础而已不断的熟悉各个I/O函数不断地在一个雏形的模型上面不断打磨最后才能出来项目的

结果没想到这个居然是一句诗哈哈只能说缘妙不可言啊哈哈可能上天都想让我知道这句话的重要性吧

（二）勿在浮沙筑高层摸谈线程池与高效并发模型

刚刚仔细仔细的看了最后两个一个是以process pool实现的 one loop per thread代码然后又看了一个是以thread pool实现的 reactor + work thread 用的工作队列先到先得

其实最开始我是想在这篇就把 thread pool + one loop per thread简易版给实现出来而且其实现在脑子里面非常有思路刚刚仔细分析了代码一个多小时感觉自己已经可以开始写了思路大概如下 process pool 主进程给子进程们消息传递采用pipe 而如果我们用 thread pool的话就可以每个都用一个thread类里面都有一个pthread_cond 条件变量我们用这个通知新进程来了

可是鉴于我目前真的没有看到线程池那种完整的代码哪怕有思路由于这一篇是打算直接实现出来一个比较简易的HTTP或者CGI服务器我怕实现出来了如果有哪个地方有问题我找不到对比代码得以验证哪里出现了问题所以呢我还是选择退而求其次先把process pool + one loop per thread 给实现出来吧其实thread pool 和 process pool 就目前而言啊我认为其实没啥差别不过一个是fork + pipe 一个是用pthread_create + cond 之后都通过子进程/线程来 accept 主进程/线程来 listen 有消息用round robin算法轮转选择一个进程/线程来运行吗…

但是这里又有个问题这里确实我还没有想到进程池子进程可以通过pipe来进行epoll_wait 那线程池的pthread_cond 怎么来弄呢进程池可以统一事件源那线程怎么处理呢算了这一篇就先从 process pool + one loop per thread 开整

手中有粮（心中有思路），自然不慌哈哈有思路那肯定实现起来也不会是很困难的事情啦

1、simple echo server 0.50 came out

1、一些在写代码时候的闲话

在经历了几个小时（好吧确实是几个小时下午发现人有点顶不住了回寝室睡觉去了）自己的echo server 0.5是已经出世了先说好看分段标题都可以看得出来这个版本是0.5 意味着是简版的echo server而且里面也有一定的内存泄漏问题因为用了singleton的进程模型但是确实我也不知道怎么处理这个static成员变量而且第一本书中的源代码里面也没有对这个全局变量进行处理（应该是）

而且在这之后我也个人编写了一个简单的不能再简单的makefile 自己却发现出了各种大大小小的问题后面自己才体会到基础知识真的有多么多么重要之前我还对编译链接的那本好书不以为意觉得在自己找到实习前就不看了等找到实习了之后工作完了休息的时候看现在看来这本书需要阅读的优先级已经提高了

而且最恼火的是什么就是我的makefile 之前加了依赖文件头文件编译的话要出现.h.gch的预编译头文件每次编译都会出现个人又觉得不太美观然后就用隐式推导关系让makefile自己去找但是之后修改了头文件竟然make显示没有改动哎估计是因为自己makefile才开始用出现各种各样的问题是必然的

还有对gcc 尽管之前自己写tiny_os的时候自己用了makefile gcc 但说句实话确实那个时候只是认真的研究了os的代码自己那个时候还不能接受makefile那种工具自己的水平对linux的认识理解也不足以让我那个时候去学习包括今天自己用gcc的时候自己也对其中的参数发生了各种各样的困扰例如-c -o 什么含义真的搞明白自己也是1个小时前的事情

所以现在也才明白学的越多写得越多发现自己不会的越多但是今天毕竟写了自己收获也会满满毕竟这个项目是我之后打算一直迭代也就是从雏形一直到后面的网络库到高性能并发http 所以自己也没有焦急毕竟所有东西也都得一步一步脚踏实地的走一遍

好了扯远了尽管书上有源代码但是我写代码的习惯是能在自己写的情况绝不看书除非自己确实没有思路了或者确实不会写了对于一些细节的把控确实还不太清楚自己再回去看看然后再把书合上自己写

上面那段话是我在对我的echo server非常不满意的时候写的按照原来的习惯我应该是会把删掉了但既然我想把这系列博客作为我从零开始一步步实现的博客的话我觉得就把上面的那段话留着吧

现在呢我对我目前实现的echo server还算是觉得可以但是呢还是存在着些许的内存泄漏所以第二本书个人认为是我后面要反复来看的而且经过自己写了这个用进程池 + one loop per thread写的echo server后我对我写过的I/O模型的理解也更深刻了之前看第二本书里面看到里面对每个模型的描述什么银行在处理客人那个时候对那些描述场景心里面一点都没有感觉现在也再回头看看心里面也有点感触

我发现这种模型是不能有长时间I/O阻塞的必须得用non-blocking 如果不是的话当连接创建后进入运行模板中后那么就会出不去所以在编写的用户处理类中必须需要很快的操作因为同一个进程池中的某一个进程不仅仅处理一个用户需要处理多个用户如果一个进程处理过久那么后面同一个进程的其他用户也就会产生等待处理得越久后面用户等待的越久最不能够接受的是用阻塞I/O 例如我现在写的echo server 如果每一个连接都用的阻塞I/O 那么只要产生8个进程且大家都保持连接那么进程池就一下子被占住了

昨晚思考的时候就忽然发现非阻塞的 recv才是解决问题的办法毕竟如果读不出来的话 recv返回是-1 我们检查一下errno 如果是EAGAIN 我们退出等下次信号来了我们再进来就好了 ^^

好了那这段话就先写到这里刚刚又想到这个echo server还有一些问题没有处理一些信号处理如果在调用recv的时候信号中断了而且信号没设置重入的话那么就会丢失数据… 所以应该再去加一下信号处理的但whatever 写出来了模板自己有个心领神会就好了至于细节现在扣没有必要之后正式进入写的时候所有的细节都得自己一点一点处理慢慢来

这里的退出处理还是比较糟糕的尤其是主函数的close( listenfd ); 子进程由于fork之后也都能进来都来关一次而我对这个server跑起来之后中断的处理方式是直接ctrl+c… 很暴力所以就没有再改了… 总之这是一个错误的代码书写方式还望请各位海涵

2、main.cc

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

#include "processpool.h"
#include "echo.h"

int main( int argc , char* argv[] )
{
	if (argc <= 2)
	{
		printf( "Usage: %s ip_address portname\n", argv[0] );
		return 0;
	}

	const char* ip = argv[1];
	int port = atoi( argv[2] );
    
	int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
	assert( listenfd >= 1 );

	struct sockaddr_in address;
	memset( &address, 0, sizeof( address ) );
	address.sin_family = AF_INET;
	address.sin_port = htons( port );
	inet_pton( AF_INET, ip, &address.sin_addr );

	int ret = 0;
	ret = bind( listenfd, (struct sockaddr*)( &address ), 
				sizeof( address ) );
	assert( ret != -1 );

	ret = listen( listenfd, 5 );
	assert( ret != -1 );
	
	processpool<echo>* pool = processpool<echo>::create( listenfd, 8 );
	pool->run();

	close( listenfd );

	return 0;
}

2、processpoll.h

#ifndef __PROCESSPOLL_H_
#define __PROCESSPOLL_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

class process
{
 public:
  int pid;              // 进程的pid
  int pipe[2];          // 父子通信管道 父 pipe[0] 子 pipe[1] socketpair双向通信
 
  process() : pid( -1 ), pipe{ 0, 0 } {}
};

template < typename T >
class processpool
{
 private:
  static const int MAX_EVENTS_NUMBER = 5;
  static const int MAX_USER_PER_PROCESS = 10000; 
  int idx;                  
  int listenfd;
  int epollfd;
  int max_processes_num;
  process* sub_processes;
  static processpool<T>* instance; 	// 涉及内存泄漏 由于是singleton模型

  processpool( int listenfd, int max_processes_num = 8 );
  ~processpool()
  {
	delete [] sub_processes;
  }

 public:
  static processpool<T>* create( int listenfd, int _max_processes_num = 8 )
  {
      if( instance == nullptr )
	  {
	      instance = new processpool<T>( listenfd, _max_processes_num );
		  return instance;
	  }

	  return instance;
  } 

  void run();
  void run_parent();
  void run_child();
  void setup_up_sig();
};

template < typename T>
processpool< T >* processpool< T > :: instance = nullptr;

template < typename T >
processpool<T>::processpool( int listenfd, int _max_processes_num ):
 						   idx( -1 ), listenfd( listenfd ), epollfd ( 0 ),
						   max_processes_num( _max_processes_num ), sub_processes( nullptr )
{
	sub_processes = new process [ max_processes_num ];
	
	for( int i = 0; i < max_processes_num; ++i )
	{
		socketpair( PF_UNIX, SOCK_STREAM, 0, sub_processes[i].pipe );
		sub_processes[i].pid = fork();
		
		if( sub_processes[i].pid > 0 )	// 父进程 关闭子进程方的pipe
		{
			close( sub_processes[i].pipe[1] );
			continue;
		}
		else
		{
			close( sub_processes[i].pipe[0] );
			idx = i;
			break;
		}
	}
}

static int set_non_blocking( int fd )
{
    int old_state = fcntl( fd, F_GETFL );
    int new_state = old_state | O_NONBLOCK;
    fcntl( fd, F_SETFL, new_state );

    return old_state;
}

static void addfd( int epollfd , int fd )
{
    epoll_event event;
    event.events = EPOLLIN | EPOLLET;
    event.data.fd = fd;
    epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );
    set_non_blocking( fd );
}

static void removefd( int epollfd, int fd )
{
	epoll_ctl( epollfd, EPOLL_CTL_DEL, fd, nullptr );
	close( fd );
}

template < typename T >
void processpool< T > :: run()
{
    if( idx == -1 )
	{
	    run_parent();
	}
	else
	{
	    run_child();
	}
}

template < typename T >
void processpool< T > :: setup_up_sig()
{
	epollfd = epoll_create( 5 );
    assert( epollfd != -1 );
}

template < typename T >
void processpool< T > :: run_parent()
{
    epoll_event events[ MAX_EVENTS_NUMBER ];
	setup_up_sig();

    addfd( epollfd, listenfd );

	int pre_idx = 0;
	int has_new_cli = 1;
	int number = 0;
	while( 1 )
	{
		number = epoll_wait( epollfd , events, MAX_EVENTS_NUMBER, -1 );
		
		for( int i = 0; i < number; ++i )
		{
			int sockfd = events[i].data.fd;
			if( sockfd == listenfd ) 
			{
				int pos = pre_idx;
				do
				{
					pos = ( pos + 1 ) % max_processes_num;
				}
				while( sub_processes[pos].pid == -1 );
				pre_idx = pos;

				send( sub_processes[pos].pipe[0], ( void* )&has_new_cli, 
						  sizeof( has_new_cli ), 0 );
				printf( "parent processes has sent msg to %d child\n", pos );
			}	
		}
	}

	// close( pipe[0] );
}


template < typename T >
void processpool< T > :: run_child()
{
	epoll_event events[ MAX_EVENTS_NUMBER ];
	setup_up_sig();

	int pipefd = sub_processes[idx].pipe[1];
	addfd( epollfd, pipefd );
	T* users = new T [MAX_USER_PER_PROCESS];

	int number = 0;
	while( 1 )
	{
		number = epoll_wait( epollfd , events, MAX_EVENTS_NUMBER, -1 );
		for( int i = 0; i < number; ++i )
		{
			int sockfd = events[i].data.fd;
			if( sockfd == pipefd && ( events[i].events & EPOLLIN ) )
			{
				struct sockaddr_in client;
                socklen_t client_addrlength = sizeof( client );
                int connfd = accept( listenfd, ( struct sockaddr* )( &client ),
                                     &client_addrlength );
				addfd( epollfd, connfd );
				users[connfd].init( epollfd, connfd, client );
				printf( "child %d is addfding \n", idx );
				continue;
			}
			else if( events[i].events & EPOLLIN )
			{
				printf( "child %d has recv msg\n", idx );
				users[sockfd].process();
			}
		}
	}

	delete [] users;
	users = nullptr;

	close( epollfd );
	close( pipefd );
}

#endif

2、echo.h

#ifndef __ECHO_H_
#define __ECHO_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

#include "processpool.h"

class echo
{
 private:
  static const int BUFFER_SIZE = 1024;
  static int epollfd;
  int sockfd;
  sockaddr_in client_addr;
  char buf[1024] = {0};

 public:
  echo()  {}
  ~echo() {}

  void init( int _epollfd, int _sockfd, const sockaddr_in& address )
  {
	epollfd = _epollfd;
	sockfd  = _sockfd;
	client_addr = address;
  } 

  void process()
  {
	  while( 1 )
	  {
		 memset( buf , 0, sizeof( buf ) );
	   	 int ret = recv( sockfd, buf, sizeof( buf ), 0 );
		 if( ret < 0 )
		 {
			if( errno == EAGAIN || errno == EWOULDBLOCK )
			{
				break;
			}
		 }
		 else if( ret == 0)
		 {
	  	 	removefd( epollfd, sockfd );
		 	break;
		 }
		 else
		 {
	  		send( sockfd, buf, sizeof( buf ), 0 );
		 }
	  }

	  return;
  }
};

int echo::epollfd = -1;

#endif