Linux学习_网络并发处理

Posted 2021-05-24 Leslie X徐

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux学习_网络并发处理相关的知识，希望对你有一定的参考价值。

服务器端并发性处理

处理方式

多进程
- 父进程accept(),获取客户端后fork()子进程
多线程
多路复用I/O

多进程服务器

/*
 * TCP服务器.c
 * 
 * 
 */

#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <signal.h>
#include <time.h>
#include <arpa/inet.h>
#include "msg.h"
#include <errno.h>
#include <wait.h>

int sockfd;

//登记信号处理函数，使程序接收ctrl+C信号时关闭服务器
void sig_handler(int signo)
{
	if(signo==SIGINT)
	{
		printf("server close\\n");
		/*步骤6：关闭客户端的socket*/
		close(sockfd);
		exit(1);
	}
	if(signo==SIGCHLD)
	{
		printf("server close\\n");
		printf("child process dead...\\n");
		wait(0);
	}
}

/*输出连接上来的客户端相关信息*/
void out_addr(struct sockaddr_in *clientaddr)
{
	//将端口号从网络字节序转换成主机字节序
	int port = ntohs(clientaddr->sin_port);
	char ip[16];
	memset(ip,0,sizeof(ip));
	//将ip地址从网络字节序转换成点分十进制
	inet_ntop(AF_INET,
					&clientaddr->sin_addr.s_addr,
					ip, sizeof(ip));
	printf("client: %s(%d) connected\\n",ip,port);
}

/*执行对客户端操作*/
void do_service(int fd)
{
	/*和客户端进行读写操作(双向通信)*/
	char buff[512];
	while(1){
		memset(buff,0,sizeof(buff));
		printf("start read and write...");
		size_t size;
		if((size = read_msg(fd,buff,sizeof(buff)))<0){
			perror("");
			break;
		}else if(size==0){
			break;
		}else{
			printf("%s\\n",buff);
			if(write_msg(fd,buff,sizeof(buff))<0){
				if(errno==EPIPE){break;}
				perror("protocol error");
			}
		}
	}
}

/*主函数*/
int main(int argc, char **argv)
{
	
	if(argc<2)
	{
		printf("usage:%s #port\\n",argv[0]); //传递端口参数
		exit(1);
	}
	/*处理ctl+c信号，关闭服务器*/
	if(signal(SIGINT, sig_handler)==SIG_ERR) 
	{
		perror("signal sigint error");
		exit(1);
	}
	if(signal(SIGCHLD, sig_handler)==SIG_ERR) 
	{
		perror("signal sigint error");
		exit(1);
	}
	
	/*步骤1：创建socket
	 * 注：socket创建在内核中，是一个结构体。
	 * AF_INET：IPv4
	 * SOCK_STREAM:tcp协议
	 * */
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	
	/*步骤2：将socket和地址(包括ip、port)进行绑定*/
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof(serveraddr));
	//往地址中填入ip、port、internet地址族类型
	serveraddr.sin_family = AF_INET; //IPv4
	serveraddr.sin_port = htons(atoi(argv[1])); //port
	serveraddr.sin_addr.s_addr = INADDR_ANY; //INADDR_ANY响应所有客户端请求
	if(bind(sockfd, (struct sockaddr*)&serveraddr,
				sizeof(serveraddr))<0)
		{perror("bind error");exit(1);}
		
	/*步骤3：调用listen启动监听(指定端口监听)
	 * 通知系统去接受来自客户端的连接请求
	 * (将接收到的客户端连接请求放置到对应的队列中)
	 * 第二个参数：指定队列长度为10
	 * */
	if(listen(sockfd, 10)<0)
	{perror("listen error");exit(1);}
	
	/*步骤4：调用accept函数，
	 * 从队列中获得一个客户端的请求连接,
	 * 并返回新的socket描述符。
	 * 若没有客户端连接，调用此函数会阻塞，直到获得一个客户端连接。
	 * */
	struct sockaddr_in clientaddr;
	socklen_t clientaddr_len = sizeof(clientaddr);
	//循环和多个客户端进行连接
	while(1){
		int fd = accept(sockfd,
								(struct sockaddr*)&clientaddr,
								&clientaddr_len);
		if(fd<0){
			perror("accept error");
			continue;
		}
	
		/*步骤5：启动子进程调用IO函数(read/write)
		 * 和连接的客户端进行双向的通信
		 * */
		 pid_t pid = fork();
		 if(pid<0){continue;}
		 else if(pid==0){//child process
			out_addr(&clientaddr);
			do_service(fd);
			/*步骤6：关闭accept返回的socket*/
			close(fd);
			break;
		 }else if(pid>0){//parent process
			 //父子进程各有一份fd，需要close
			 close(fd);
		 }
	}
	
	return 0;
}

多线程服务器

/*
 * TCP服务器.c
 * 
 * 
 */


#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <signal.h>
#include <time.h>
#include <arpa/inet.h>
#include "msg.h"
#include <errno.h>
#include <pthread.h>

int sockfd;

//登记信号处理函数，使程序接收ctrl+C信号时关闭服务器
void sig_handler(int signo)
{
	if(signo==SIGINT)
	{
		printf("server close\\n");
		/*步骤6：关闭客户端的socket*/
		close(sockfd);
		exit(1);
	}

}

/*执行对客户端操作*/
void do_service(int fd)
{
	/*和客户端进行读写操作(双向通信)*/
	char buff[512];
	while(1){
		memset(buff,0,sizeof(buff));
		size_t size;
		if((size = read_msg(fd,buff,sizeof(buff)))<0){
			perror("");
			break;
		}else if(size==0){
			break;
		}else{
			printf("%s\\n",buff);
			if(write_msg(fd,buff,sizeof(buff))<0){
				if(errno==EPIPE){break;}
				perror("protocol error");
			}
		}
	}
}

void out_fd(int fd)
{
	struct sockaddr_in addr;
	socklen_t len = sizeof(addr);
	//从fd中获得客户端的相关信息并放置到sockaddr_in中
	int err = getpeername(fd,(struct sockaddr*)&addr,&len);
	if(err<0){perror("getname error");return;}
	char ip[16];
	memset(ip,0,sizeof(ip));
	int port = ntohs(addr.sin_port);
	inet_ntop(AF_INET,
				&addr.sin_addr.s_addr, 
				ip, sizeof(ip));
	printf("%16s(%5d) closed!\\n",ip,port);
	
}

void* th_fn(void* arg)
{
	int fd = (int)arg;
	do_service(fd);
	out_fd(fd);
	close(fd);
	
	return NULL;
}

/*主函数*/
int main(int argc, char **argv)
{
	
	if(argc<2)
	{
		printf("usage:%s #port\\n",argv[0]); //传递端口参数
		exit(1);
	}
	/*处理ctl+c信号，关闭服务器*/
	if(signal(SIGINT, sig_handler)==SIG_ERR) 
	{
		perror("signal sigint error");
		exit(1);
	}
	
	/*步骤1：创建socket
	 * 注：socket创建在内核中，是一个结构体。
	 * AF_INET：IPv4
	 * SOCK_STREAM:tcp协议
	 * */
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	
	/*步骤2：将socket和地址(包括ip、port)进行绑定*/
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof(serveraddr));
	//往地址中填入ip、port、internet地址族类型
	serveraddr.sin_family = AF_INET; //IPv4
	serveraddr.sin_port = htons(atoi(argv[1])); //port
	serveraddr.sin_addr.s_addr = INADDR_ANY; //INADDR_ANY响应所有客户端请求
	if(bind(sockfd, (struct sockaddr*)&serveraddr,
				sizeof(serveraddr))<0)
		{perror("bind error");exit(1);}
		
	/*步骤3：调用listen启动监听(指定端口监听)
	 * 通知系统去接受来自客户端的连接请求
	 * (将接收到的客户端连接请求放置到对应的队列中)
	 * 第二个参数：指定队列长度为10
	 * */
	if(listen(sockfd, 10)<0)
	{perror("listen error");exit(1);}
	
	/*步骤4：调用accept函数，
	 * 从队列中获得一个客户端的请求连接,
	 * 并返回新的socket描述符。
	 * 若没有客户端连接，调用此函数会阻塞，直到获得一个客户端连接。
	 * */
	struct sockaddr_in clientaddr;
	socklen_t clientaddr_len = sizeof(clientaddr);
	//循环和多个客户端进行连接
	while(1){
		//主控线程负责调用accept去获得客户连接
		//int fd = accept(sockfd,
								//(struct sockaddr*)&clientaddr,
								//&clientaddr_len);
		//直接从fd也可以读取客户端信息
		int fd = accept(sockfd,NULL,NULL);
		if(fd<0){
			perror("accept error");
			continue;
		}
	
		/*步骤5：启动子线程调用IO函数(read/write)
		 * 和连接的客户端进行双向的通信
		 * */
		pthread_t th;
		int err;
		err = pthread_create(&th,0,th_fn,(void*)fd);
		if(err){perror("create error");}
		//以分离状态启动子线程
		pthread_detach(th);
	}
	
	return 0;
}

客户端：发送数据给服务器，服务器再返回给客户端

/*
 * echo_tcp_client.c
 * 
 */

#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h> //包含宏STDOUT_FILENO
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <arpa/inet.h>//包含函数inet_pton
#include "msg.h"

int main(int argc, char **argv)
{
	if(argc<3){
		printf("usage: %s ip port\\n",argv[0]);
		exit(1);
	}
	
	/*步骤1：创建socket*/
	int sockfd = socket(AF_INET, SOCK_STREAM,0);
	if(sockfd<0){printf("socket error");exit(1);}
	
	//往serveraddr中填入ip,port和地址族类型
	struct sockaddr_in serveraddr;
	memset(&serveraddr,0,sizeof(serveraddr));
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(atoi(argv[2]));
	//将ip地址转换成网络字节序
	inet_pton(AF_INET,argv[1],
					&serveraddr.sin_addr.s_addr);
	/*步骤2：客户端调用connect函数连接到服务器端*/
	if(connect(sockfd, 
			(struct sockaddr*)&serveraddr,
			sizeof(serveraddr))<0){
			perror("connect error");
			exit(1);
		}
	
	/*步骤3：调用IO函数(read/write)和服务器端进行双向通信*/
	char buff[512];
	size_t size;
	char *prompt = ">";//提示符
	while(1){
		memset(buff,0,sizeof(buff));
		write(STDOUT_FILENO, prompt, 1);
		size = read(STDIN_FILENO, buff, sizeof(buff));
		if(size<0) continue;
		buff[size-1]='\\0';
		
		if(write_msg(sockfd, buff,sizeof(buff))<0){
			perror("write msg error");
			continue;
		}else{
			if(read_msg(sockfd,buff,
							sizeof(buff))<0){
				perror("read message error");
				continue;
			}else{
				printf("%s\\n",buff);
			}
		}
	}
	/*步骤4：关闭socket*/
	close(sockfd);

	return 0;
}

以上是关于Linux学习_网络并发处理的主要内容，如果未能解决你的问题，请参考以下文章

Linux 网络编程九（select应用--大并发处理）

Linux网络学习_网络的基本概念

译文：18个实用的JavaScript代码片段，助你快速处理日常编程任务

Linux(Centos )的网络内核参数优化来提高服务器并发处理能力

Linux(debian)的网络内核参数优化来提高服务器并发处理能力

Linux(Centos )的网络内核参数优化来提高服务器并发处理能力