Linux网络编程：多进程的服务端

多进程的服务端

多进程服务端工作流程

• socket():创建服务端的socket

• bind():将通信地址和端口号绑定到socket上

• listen():把socket设置为监听模式(TCP3次握手)

• accept():接受客户端的连接

• fork():创建子进程

  • recv()/send():与客户端通信

  • return 0/exit(0):结束子进程

  • close():关闭socket

代码示例

服务端代码

//code05.cpp code_tree 多进程的服务端 
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<arpa/inet.h>
#include<assert.h>
#include<siganl.h>

#define BUFFER_SIZE 1024

class Server
{
private:
    int m_listenfd;   // 服务端用于监听的socket
    int m_connfd;  	  // 客户端连上来的socket
public:
    Server();
    
    bool InitServer(int port);  // 初始化服务端
    bool Accept();  			// 等待客户端的连接
    int  Send(const void *buf,const int buflen);
    int  Recv(void *buf,const int buflen);
    void Closelistenfd();	//关闭用于监听socket
    void Closeconnfd();		//关闭用于连接的socket
 
   ~Server();
};

int main()
{
    Server server;
    //signal(SIGCHLD,SIG_IGN);//忽略子进程的退出信号,避免产生僵尸进程
    
    if(server.InitServer(5051)==false)
        return -1;
    while(1)
    {
        if(server.Accept()==false)
  	    	  return -1;
  	  	printf("connect ok\n");
        if(fork()>0)
        {
            //父进程回到while重新accept
            server.Closeconnfd();
            continue;
        }
        
    	server.Closelistenfd();
        printf("子进程与客户端连接\n");
        
    	char buffer[BUFFER_SIZE];
    	while(1)
   		{
        	memset(buffer,0,BUFFER_SIZE);
        	if(server.Recv(buffer,BUFFER_SIZE-1)<=0)
            	break;
        	printf("接收: %s\n",buffer);
        
        	strcpy(buffer,"成功接收");
        	if(server.Send(buffer,strlen(buffer))<=0)
            	break;
        	printf("发送: %s\n",buffer);
    	}
    	
    	printf("连接断开\n");
        return 0;	//或exit(0),子进程退出
    }
}

Server::Server():m_listenfd(0),m_connfd(0){}
Server::~Server()
{
    if(m_listenfd!=0)	
        close(m_listenfd);
    if(m_connfd!=0)		
        close(m_connfd);
}

bool Server::InitServer(int port)
{
    m_listenfd=socket(AF_INET,SOCK_STREAM,0);
 
    struct sockaddr_in servaddr; 
    memset(&servaddr,0,sizeof(servaddr));
    servaddr.sin_family = AF_INET; 
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    servaddr.sin_port = htons(port);
    
    if(bind(m_listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
    { 
        close(m_listenfd);
        m_listenfd=0; 
        return false; 
    }
    
    if (listen(m_listenfd,5) != 0 )
    { 
        close(m_listenfd);
     	m_listenfd=0;
    	return false; 
    }
    
    return true;
}

bool Server::Accept()
{
    if((m_connfd=accept(m_listenfd,0,0))<=0)
        return false;
    return true;
}

int Server::Send(const void* buf,const int buflen)
{
    return send(m_connfd,buf,buflen,0);
}
int Server::Recv(void* buf,const int buflen)
{
    return recv(m_connfd,buf,buflen,0);
}
void Server::Closelistenfd()
{
    close(m_listenfd);
    m_listenfd=0;
}
void Server::Closeconnfd()
{
    close(m_connfd);
    m_connfd=0;
}

客户端代码

稍微修改一下之前我们用过的客户端代码code04，使之每次发送数据后sleep(10)。

注意事项

fork函数

#include<sys/types>
#include<unistd.h>
pid_t fork(void);

• 该函数每次调用都返回两次，在父进程中返回子进程的PID，在子进程中则返回0，返回值是后续代码判断当前进程是父进程还是子进程。

• fork函数复制当前进程，在内核进程表中创建一个新的进程表项。新的进程表项有很多属性和原进程相同，但信号位图被清除。

• 子进程代码与父进程代码完全相同，同时还会复制父进程的数据。如果我们在程序中分配了大量内存，那么使用fork使也应当十分谨慎，尽量避免没必要的内存分配和数据复制，在Server类中添加两个close函数。

void Closeconnfd();    // 关闭客户端的socket
void Closelistenfd();    // 关闭用于监听的socket

• 父进程只负责监听客户端的连接，不需要与客户端通信，所以父进程close(m_connfd)对子进程无影响。
• 同理，子进程负责与客户端通信，关闭复制而来的m_listenfd对父进程无影响。
• 子进程完成任务后，要调用return 0或exit(0)。

僵尸进程

我们在服务端运行code05，在多个客户端分别运行code04后等待连接断开，用ps -ef | grep code05观察进程情况。

有<defunct>标志的进程为僵尸进程。僵尸进程在消失之前会继续占用系统资源。

产生僵尸进程的原因

• 子进程结束运行时，内核不会立即释放该进程的进程表表项，以满足父进程后续对该子进程退出信息的查询。在子进程结束运行与父进程查询之间时子进程处于僵尸状态。
• 父进程结束或者异常终止，子进程继续运行，此时子进程由init进程接管，在其结束运行之前处于僵尸状态。

处理僵尸进程

• 父进程处理子进程的返回信息

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int* stat_loc);
pid_t waitpid(pid_t pid,int* stat_loc,int options);

wait函数将阻塞进程，直到进程的某个子进程结束运行，它返回子进程的PID，并将子进程的退出状态存储与stat_loc参数指向的内存中。

waitpid只等待由pid参数指定的子进程中，如果pid为-1，则waitpid与wait函数相同。

options参数可以控制waitpid函数的行为，常用取值为WNOHANG，此时的waitpid为非阻塞的。

• 父进程忽视子进程的退出信号

signal(SIGCHLD,SIG_IGN);
//忽略子进程的退出信号,避免产生僵尸进程