文章目录
- 一.并发的服务端
- 1.多进程的服务端代码
- 1.1 代码解析
- 1.2 自己写的代码
- 2.客户端代码
- 2.1示例
- 2.2 自己写的代码
- 3.运行效果
- 3.1 服务端与多个客户端通信
- 3.2 用 ps -ef|grep C++ 命令查看
- 二.僵尸进程(zombie)
- 1.僵尸进程产生的原因
- 1.2 生成僵尸进程
- 2.僵尸进程的危害
- 3.如何解决僵尸进程
- 3.1 第一种方法:父进程调用 waid()
- 3.2 第二种方法:调用 signal ()
- 3.3 测试调用 signal(SIGCHLD,SIG_IGN)效果
- 三.单进程和多进程
- 四.补充
- 4.1 父子进程都没有关闭 通信socket 的问题
- 4.1.1 修改服务端主程序的代码
- 4.1.2 客户端主程序的测试代码
- 4.1.3 运行效果
前面的章节介绍socket通信的时候,socket的服务端在同一时间只能和一个客户端通信,并不是服务端有多忙,而是因为第单进程的程序在同一时间只能做一件事情,不能一边等待客户端的新连接一边与其他的客户端进行通信。
一.并发的服务端
如果把 socket 服务端改为多进程,在每次 accept 到一个客户端的连接后,生成一个子进程,让子进程负责和这个客户端通信,父进程继续 accept 客户端的连接。socket 的服务端在监听新客户端的同时,还可以与多个客户端进行通信。这就是并发,如下图
1.多进程的服务端代码
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
class CTcpServer
{
public:
int m_listenfd; // 服务端用于监听的socket
int m_clientfd; // 客户端连上来的socket
CTcpServer();
bool InitServer(int port); // 初始化服务端
bool Accept(); // 等待客户端的连接
// 向对端发送报文
int Send(const void *buf,const int buflen);
// 接收对端的报文
int Recv(void *buf,const int buflen);
void CloseClient(); // 关闭客户端的socket
void CloseListen(); // 关闭用于监听的socket
~CTcpServer();
};
CTcpServer TcpServer;
int main()
{
// signal(SIGCHLD,SIG_IGN); // 忽略子进程退出的信号,避免产生僵尸进程
if (TcpServer.InitServer(5051)==false)
{ printf("服务端初始化失败,程序退出。\n"); return -1; }
while (1)
{
if (TcpServer.Accept() == false) continue;
if (fork()>0) { TcpServer.CloseClient(); continue; } // 父进程回到while,继续Accept。
// 子进程负责与客户端进行通信,直到客户端断开连接。
TcpServer.CloseListen();
printf("客户端已连接。\n");
// 与客户端通信,接收客户端发过来的报文后,回复ok。
char strbuffer[1024];
while (1)
{
memset(strbuffer,0,sizeof(strbuffer));
if (TcpServer.Recv(strbuffer,sizeof(strbuffer))<=0) break;
printf("接收:%s\n",strbuffer);
strcpy(strbuffer,"ok");
if (TcpServer.Send(strbuffer,strlen(strbuffer))<=0) break;
printf("发送:%s\n",strbuffer);
}
printf("客户端已断开连接。\n");
return 0; // 或者exit(0),子进程退出。
}
}
CTcpServer::CTcpServer()
{
// 构造函数初始化socket
m_listenfd=m_clientfd=0;
}
CTcpServer::~CTcpServer()
{
if (m_listenfd!=0) close(m_listenfd); // 析构函数关闭socket
if (m_clientfd!=0) close(m_clientfd); // 析构函数关闭socket
}
// 初始化服务端的socket,port为通信端口
bool CTcpServer::InitServer(int port)
{
if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0; }
m_listenfd = socket(AF_INET,SOCK_STREAM,0); // 创建服务端的socket
// 把服务端用于通信的地址和端口绑定到socket上
struct sockaddr_in servaddr; // 服务端地址信息的数据结构
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET; // 协议族,在socket编程中只能是AF_INET
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 本主机的任意ip地址
servaddr.sin_port = htons(port); // 绑定通信端口
if (bind(m_listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
{ close(m_listenfd); m_listenfd=0; return false; }
// 把socket设置为监听模式
if (listen(m_listenfd,5) != 0 ) { close(m_listenfd); m_listenfd=0; return false; }
return true;
}
bool CTcpServer::Accept()
{
if ( (m_clientfd=accept(m_listenfd,0,0)) <= 0) return false;
return true;
}
int CTcpServer::Send(const void *buf,const int buflen)
{
return send(m_clientfd,buf,buflen,0);
}
int CTcpServer::Recv(void *buf,const int buflen)
{
return recv(m_clientfd,buf,buflen,0);
}
void CTcpServer::CloseClient() // 关闭客户端的socket
{
if (m_clientfd!=0) { close(m_clientfd); m_clientfd=0; }
}
void CTcpServer::CloseListen() // 关闭用于监听的socket
{
if (m_listenfd!=0) { close(m_listenfd); m_listenfd=0; }
}
1.1 代码解析
(1)在CTcpServer 中增加了两个成员函数
void CloseClient(); // 关闭客户端的socket
void CloseListen(); // 关闭用于监听的socket
(2)当有客户端连接上来的时候,主进程执行 fork() ,这时候客户端的 socket(m_clientfd),也就是用于通信的socket,被赋值了一份。但是对于父进程来说,只负责监听客户端的连接,不需要与客户端通信,所以父进程要关闭通信的 socket,关闭了对子进程的通信 socket 没有影响。
if (TcpServer.Accept() == false) continue;
if (fork()>0) { TcpServer.CloseClient(); continue; } // 父进程回到while,继续Accept。
(3)当有客户端连接上来,主进程执行 fork(),这时候用于监听的 socket(m_listentfd) 也会被复制一份。但是对于子进程来说,它不需要监听客户端的连接,只需要与客户端进行通信。关闭了对父进程没有影响。
// 子进程负责与客户端进行通信,直到客户端断开连接。
TcpServer.CloseListen();
(4)当一个子进程执行完任务后,要跳出循环——调用 return 或 exit(0) 退出,如果没有调用 return 或 exit(0),子进程将又回到 while() 循环的首部,又继续生成子进程。
(5)什么时候 fork(),也就是说什么时候去产生一个子进程。当有一个客户端连接了,与服务端形成了用于通信的socket,就产生一个子进程。让这个子进程和这个客户端使用这个socket通信。就像是酒店,当有一个客人来了,就派一个服务员过去接待,派服务员员过去的前提是客人来了。所以什么时候fork 出一个子进程也是这个道理。
if (TcpServer.Accept() == false) continue;
if (fork()>0) { TcpServer.CloseClient(); continue; } // 父进程回到while,继续Accept。
1.2 自己写的代码
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
class CTcpServer
{
public:
int m_listenSocket; //服务端用于监听的socket
int m_comuSocket; //客户端连接上来的socket,也就是用于通信的socket
CTcpServer(); //构造函数
bool InitServer(int port); //初始化服务端的地址信息```
bool Accept(); //等待客户端的连接;从等待连接的队列中获取连接请求
int Send(const void *buf ,const int buflen); //发送数据的函数
int Recv( void *buf, const int buflen); //接收数据的函数
~CTcpServer(); //析构函数
void CloseClient(); //关闭客户端的socket
void CloseListen(); //关闭用于监听的socket
};
int main(int argc,char *argv[])
{
if(argc!=2)
{
printf("Using: ./server port\n");
printf("Example: ./C++封装服务端 5005\n");
return -1;
}
CTcpServer TcpServer;
//监听的socket已经建立,但是还没有绑定,要先绑定服务器的端口,这个属于初始化的
if (TcpServer.InitServer(atoi(argv[1])) == false)
{
printf("连接服务器失败\n");
return -1;
}
while(1)
{
if(TcpServer.Accept() == false)
{
printf("TcpServer.Accept\n");
while(1)
{
if(TcpServer.Accept() == false)
{
printf("TcpServer.Accept\n");
continue; //如果失败的话,继续监听
}
//sleep(30);
if( fork()>0) { TcpServer.CloseClient(); continue;}
TcpServer.CloseListen();
//子进程与客户端进行通信,知道客户端断开连接。
//因为建立连接后,子进程的监听socket就不需要了,需要关闭。
//当父进程回到循环的开始时,监听的socket会再次打开。
printf("客户端已连接.\n");
char buffer[1024];
while(1)
{
memset(buffer,0,sizeof(buffer));
if( TcpServer.Recv(buffer,sizeof(buffer))<=0) break;
printf("接收:%s\n",buffer);
strcpy(buffer,"ok");
if ( TcpServer.Send(buffer,sizeof(buffer))<=0) break;
printf("发送:%s\n",buffer);
}
printf("客户端已经断开连接\n");
return 0; //子进程完成通信,就退出循环
}
}
CTcpServer::CTcpServer()
{
//构造函数,初始化成员变量
m_listenSocket=0;
m_comuSocket=0;
}
CTcpServer::~CTcpServer()
{
//析构函数释放资源
if( m_listenSocket !=0) close(m_listenSocket);
if( m_comuSocket !=0) close(m_comuSocket);
}
bool CTcpServer::InitServer(int port)
{
//初始化函数,初始化服务端的地址信息
m_listenSocket = socket(AF_INET,SOCK_STREAM,0); //创建监听的socket
//将监听的socket和服务端的地址信息绑定前,先填写服务端的地址信息
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET ;
servaddr.sin_port = htons(port);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
//服务端的地址信息有了,就可以将m_listenSocket 与服务端绑定。
if( (bind(m_listenSocket,(struct sockaddr *)&servaddr,sizeof(servaddr)) ) !=0)
{ close(m_listenSocket); m_listenSocket=0; return false; }
//将监听socket设置为监听状态
if ( listen(m_listenSocket,5) != 0 )
{ close(m_listenSocket); m_listenSocket=0; return false; }
return true;
}
bool CTcpServer::Accept()
{
//accept函数将监听的socket与客户端连接起来,形成通信的socket。
//accept函数,从准备好连接的队列中取出一个客户端,与m_listenSocket连接
//客户端的信息用结构体存放
struct sockaddr_in clientaddr;
memset(&clientaddr,0,sizeof(clientaddr));
//这里其实你只要设一个结构体就行了,不用再写客户端用什么协议等等
//因为accept函数从等待队列里面提取出来就包含了客户端的地址信息,你在写的话就画蛇添足了
int socklen = sizeof(struct sockaddr_in);
if((m_comuSocket=accept(m_listenSocket,(struct sockaddr *)&clientaddr,(socklen_t *)&socklen))<=0)
return false;
return true;
}
int CTcpServer::Send(const void *buf,const int buflen)
{
return send(m_comuSocket,buf,buflen,0);
}
int CTcpServer::Recv(void *buf,const int buflen)
{
return recv(m_comuSocket,buf,buflen,0);
}
void CTcpServer::CloseClient()
{
if(m_comuSocket!=0) { close(m_comuSocket) ; m_comuSocket=0; }
}
void CTcpServer::CloseListen()
{
if(m_listenSocket!=0) { close(m_listenSocket); m_listenSocket=0; }
}
2.客户端代码
2.1示例
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
// TCP客户端类
class CTcpClient
{
public:
int m_sockfd;
CTcpClient();
// 向服务器发起连接,serverip-服务端ip,port通信端口
bool ConnectToServer(const char *serverip,const int port);
// 向对端发送报文
int Send(const void *buf,const int buflen);
// 接收对端的报文
int Recv(void *buf,const int buflen);
~CTcpClient();
};
int main()
{
CTcpClient TcpClient;
// 向服务器发起连接请求
if (TcpClient.ConnectToServer("172.16.0.15",5051)==false)
{ printf("TcpClient.ConnectToServer(\"172.16.0.15\",5051) failed,exit...\n"); return -1; }
char strbuffer[1024];
for (int ii=0;ii<50;ii++)
{
memset(strbuffer,0,sizeof(strbuffer));
sprintf(strbuffer,"这是第%d个超级女生,编号%03d。",ii+1,ii+1);
if (TcpClient.Send(strbuffer,strlen(strbuffer))<=0) break;
printf("发送:%s\n",strbuffer);
memset(strbuffer,0,sizeof(strbuffer));
if (TcpClient.Recv(strbuffer,sizeof(strbuffer))<=0) break;
printf("接收:%s\n",strbuffer);
sleep(1); // sleep一秒,方便观察程序的运行。
}
}
CTcpClient::CTcpClient()
{
m_sockfd=0; // 构造函数初始化m_sockfd
}
CTcpClient::~CTcpClient()
{
if (m_sockfd!=0) close(m_sockfd); // 析构函数关闭m_sockfd
}
// 向服务器发起连接,serverip-服务端ip,port通信端口
bool CTcpClient::ConnectToServer(const char *serverip,const int port)
{
m_sockfd = socket(AF_INET,SOCK_STREAM,0); // 创建客户端的socket
struct hostent* h; // ip地址信息的数据结构
if ( (h=gethostbyname(serverip))==0 )
{ close(m_sockfd); m_sockfd=0; return false; }
// 把服务器的地址和端口转换为数据结构
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
// 向服务器发起连接请求
if (connect(m_sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
{ close(m_sockfd); m_sockfd=0; return false; }
return true;
}
int CTcpClient::Send(const void *buf,const int buflen)
{
return send(m_sockfd,buf,buflen,0);
}
int CTcpClient::Recv(void *buf,const int buflen)
{
return recv(m_sockfd,buf,buflen,0);
}
2.2 自己写的代码
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
class CTcpClient
{
public:
int m_comuSocket;
CTcpClient();
~CTcpClient();
int ConnectToServer(const char *Serverip,const int port);
int Send(const void * buffer,const int bufferLen);
int Recv(void * buffer,const int bufferLen);
};
int main(int argc ,char *argv[])
{
if(argc != 3)
{
printf("Example: ./C++封装客户端 8.131.80.81 5005\n");
return -1;
}
CTcpClient TcpClient;
int port=atoi(argv[2]);
if( ( TcpClient.ConnectToServer(argv[1],port) ) == -1)
{
printf("连接服务器失败、\n");
return -1;
}
char buffer[1024];
while(1)
{
memset(buffer,0,sizeof(buffer));
printf("请输入要发送的内容:");
scanf("%s",buffer);
if( (TcpClient.Send(buffer,sizeof(buffer)))<=0) break;
printf("发送:%s\n",buffer);
memset(buffer,0,sizeof(buffer));
if( ( TcpClient.Recv(buffer,sizeof(buffer))) <=0) break;
printf("接收:%s\n",buffer);
sleep(1); //方便观察
}
}
CTcpClient::CTcpClient()
{
m_comuSocket=0;
}
int CTcpClient::ConnectToServer(const char *Serverip,const int port)
{
//连接服务端要用到服务端的地址信息,这个地址信息可以从ip地址中解析,用结构体来存放
//解析IP地址的函数,ip地址有时候是给域名,所以用gethostbyname函数来解析,它可以解析ip
//也可以解析域名。
//gethostbyname函数返回的是 hostent 结构体的地址
//但是connect 函数中服务端的地址是 sockaddr,
//所以要定义一个结构体(sockaddr) 来存放,解析后的服务端的地址信息
m_comuSocket = socket (AF_INET,SOCK_STREAM,0);
struct sockaddr_in servaddr; //这个结构体用来存放解析后的服务端信息
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
struct hostent * h;
if( (h=gethostbyname(Serverip)) ==0)
{ close(m_comuSocket); return -1; }
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
//向服务端发起连接请求
if( connect(m_comuSocket,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
{
close(m_comuSocket); m_comuSocket=0; return -1;
}
return 0;
}
int CTcpClient::Send(const void * buffer,const int bufferLen)
{
return send(m_comuSocket,buffer,bufferLen,0);
}
int CTcpClient::Recv(void * buffer,const int bufferLen)
{
return recv(m_comuSocket,buffer,bufferLen,0);
}
CTcpClient::~CTcpClient()
{
if(m_comuSocket !=0) close(m_comuSocket);
}
3.运行效果
3.1 服务端与多个客户端通信
先启动服务端,然后启动多个客户端。服务端同时与多个客户端通信。
3.2 用 ps -ef|grep C++ 命令查看
注意:服务端的 main() 的 while() 是死循环,没有退出机制,可以按 Ctrl+c 强制中止它,但这不是正确的方法。
二.僵尸进程(zombie)
1.僵尸进程产生的原因
僵尸进程是当子进程比父进程先结束,而父进程又没有回收子进程,释放子进程占用的资源,此时子进程将成为一个僵尸进程。
一个子进程在调用 return 或 exit(0) 结束自己的声明的时候,其实它并没有真正的被销毁,而是留下一个僵尸进程。
1.2 生成僵尸进程
(1)先启动服务端程序,然后多次启动客户端程序,马上查看服务端的进程。
(2)所有的客户端程序运行完成之后,再查看服务端的进程。
这几个进程的状态就有 的标志,这就是僵尸进程。
(3)如果按 Ctrl+c 终止服务端程序后,父进程退出,僵尸进程随之消失。
2.僵尸进程的危害
僵尸进程是子进程结束时,父进程还没有结束,没有回收子进程占用的资源。僵尸进程在消失之前会继续占用系统资源。这就是白发人送黑发人,肯定是不正常的。
如果父进程先退出,子进程被系统接管,子进程退出后系统会回收其占用的相关资源,不会成为僵尸进程。
3.如何解决僵尸进程
解决僵尸进程有两种方法。
3.1 第一种方法:父进程调用 waid()
子进程在退出之前,会向父进程发送一个信号,父进程调用 waid() 函数等待这个信号,只要等到了就不会产生僵尸进程。这看起来很简单,但在并发的服务程序中是不可能得。因为父进程还要做其他的事情,例如等待客户端的新连接,不可能去等待子进程的退出信号,这方法就不介绍了。
这就好比餐厅,当有客人来的时候肯定会有服务员去接待,但是客人吃完了之后,要走了的时候,餐厅不会专门再派个服务员去伺候你离开。餐厅是分清轻重缓急的,系统也是一样。
3.2 第二种方法:调用 signal ()
这种方法是父进程直接忽略子进程的退出信号,
具体做法就是在主程序(main)中启用一下代码:
signal(SIGCHLD,SIG_IGN); //忽略子进程的退出信号,避免产生僵尸进程
3.3 测试调用 signal(SIGCHLD,SIG_IGN)效果
(1)先启动服务端程序,然后启动多个客户端程序,查看服务端的进程。红框的为父进程
(2)客户端都运行完毕,再次查看服务端的进程。没有出现僵尸进程了(< defunct >)
三.单进程和多进程
在实际开发中,采用多进程的主要目的是处理多个并发的任务,而不是为了提高程序的效率。
从效率方面来说,某些场景下多进程的效率比单进程低,原因很简单,因为在有限的硬件资源中,多进程程序的内存开销更大,还会产生资源的竞争。就像一个人同时只做一件事,比同时做多件事快。
四.补充
4.1 父子进程都没有关闭 通信socket 的问题
当父子进程都没有关闭 socket 的时候回发生什么?前面的服务端程序,父进程是关闭用于通信的 socket 的,只是子进程的通信 socket 是打开的,所以只是子进程能与客户端进行通信(能接收到客户端所发的报文)。
那现在我把父子进程用于通信的 socket 都打开,那么客户端所发的报文,会被哪个进程用于通信 的socket 接收。
4.1.1 修改服务端主程序的代码
(1)就是不关闭父进程的通信 socket,关闭子进程的监听socket。
//监听的socket已经建立,但是还没有绑定,要先绑定服务器的端口,这个属于初始化的
if (TcpServer.InitServer(atoi(argv[1])) == false)
{
printf("连接服务器失败\n");
return -1;
}
char buffer[1024];
while(1)
{
if(TcpServer.Accept() == false)
{
printf("TcpServer.Accept\n");
continue; //如果失败的话,继续监听
}
if( fork()>0) //{ TcpServer.CloseClient(); continue;}
{
while(1)
{
memset(buffer,0,sizeof(buffer));
if( TcpServer.Recv(buffer,sizeof(buffer))<=0) break;
printf("父进程接收:%s\n",buffer);
}
sleep(1);
}
else
{
TcpServer.CloseListen();
char buffer[1024];
while(1)
{
memset(buffer,0,sizeof(buffer));
if( TcpServer.Recv(buffer,sizeof(buffer))<=0) break;
printf("儿子接收:%s\n",buffer);
}
}
}
}
4.1.2 客户端主程序的测试代码
while(1)
{
strcpy(buffer,"香香,我爱你");
int bufferlen=strlen(buffer);
if( (TcpClient.Send(buffer,bufferlen))<=0) break;
printf("发送:%s\n",buffer);
sleep(1);
}
4.1.3 运行效果
会发现当客户端发送过来时,由谁来接收时不一定的。