网络编程-TCP并发服务器-多点通信-域套接字

最新推荐文章于 2024-09-03 21:17:49 发布
最新推荐文章于 2024-09-03 21:17:49 发布
阅读量672 收藏 2
点赞数 23
文章标签： 网络 服务器 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DJQ2020391635/article/details/139101704
版权

多进程实现TCP并发：依赖于while循环模式可初步实现并发功能，但是由于accpet函数和读写函数是阻塞的，导致必须要等待阻塞结束下一个用户才能连接，所以考虑使用多进程。

思路：将与客户端建立连接设置成父进程，将与客户端通信设置成子进程，考虑到客户结束通信需退出子进程，并防止僵尸进程，需回收子进程资源，故将回收进程函数设置成非阻塞，同时利用signal函数(SIGCHLD)实现一旦发现子进程死亡，立即发送信号回收进程资源，最后还需考虑子进程是完全拷贝父进程内存，需分别关闭文件描述符。

#include<head.h>
void handler(int signo);
int main(int argc, const char *argv[])
{
	if(signal(SIGCHLD,handler)==SIG_ERR){
		perror("signal");
		return -1;
	}
	//创建进程并发服务端
	//创建端点
	int sfd=socket(AF_INET,SOCK_STREAM,0);
	//参数1表示使用ipv4通信域
	//参数2表示使用TCP面向连接的通信方式
	//参数3表示补充通信协议，由于第二个参数已经指定通信方式，故写0
	if(sfd==-1){
		perror("socket");
		return 1;
	}
	else{
		printf("创建端点成功\n");
	}
	//调用端口快速重用函数
	int reuse=1;
	if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))==-1){
		perror("setsockopt");
		return -1;
	}
	//将套结文件与IP地址与端口绑定
	struct sockaddr_in ip_port;
	char* ip="192.168.176.130";
	uint16_t port=8888;
	ip_port.sin_family=AF_INET;
	ip_port.sin_port=htons(port);
	ip_port.sin_addr.s_addr=inet_addr(ip);
	int retbind=bind(sfd,(struct sockaddr*)&ip_port,sizeof(ip_port));
	if(retbind==-1){
		perror("bind");
		return 1;
	}
	else if(retbind==0){
		printf("端口和IP绑定成功\n");
	}
	//将套接字设置为被动监听模式
	int retlisten=listen(sfd,128);
	if(retlisten==-1){
		perror("listen");
		return 1;
	}
	else if(retlisten==0){
		printf("设置监听成功\n");
	}
	//阻塞等待客户端连接
	struct sockaddr_in ser_ip_port;
	socklen_t addrlen=sizeof(ser_ip_port);
	int retaccept=-1;
	while(1){
		//父进程负责等待客户连接
		retaccept=accept(sfd,(struct sockaddr*)&ser_ip_port,&addrlen);
		if(retaccept==-1){
			perror("accept");
			return 1;
		}
		else{
			printf("客户端连接成功\n");
			printf("客户端IP：%s 客户端端口：%d\n",inet_ntoa(ser_ip_port.sin_addr),ntohs(ser_ip_port.sin_port));
		}
		pid_t pid=fork();
		if(pid>0){
			//父进程
			close(retaccept);
			}
		//与客户端相互通信
		else if(pid==0){
			close(sfd);//子进程完全拷贝父进程，所以需要关闭sfd
			char wbuf[128]={0};
			char rbuf[128]={0};
			while(1){
				bzero(wbuf,0);
				bzero(rbuf,0);
				int retread=read(retaccept,rbuf,128);
				if(retread==0){//套结断开连接
					printf("客户端断开连接\n");
					break;
				}
				printf("读取客户端内容：%s\n",rbuf);
				strcat(rbuf,"<服务端已成功读取>");
				write(retaccept,rbuf,128);
				printf("成功回复客服端\n");
			}
			close(retaccept);
			//退出子进程
			exit(EXIT_SUCCESS);
		}
		else{
			perror("fork");
			return -1;
		}
	}
		close(sfd);
	return 0;
} 
void handler(int signo){
	if(signo==SIGCHLD){
		//设置成非阻塞
		while(waitpid(-1,NULL,WNOHANG)>0);
	}

}

多线程实现TCP并发：

思路：主线程实现与客户端的连接，子线程实现与客户端实现通信，由于线程是去运行指定的代码片，所以避免不了局部变量问题，所以需注意指定运行的代码与主函数之间变量的关系，需要传参。

#include<head.h>
void* interaction(void* arg);
int main(int argc, const char *argv[])
{
	//使用线程实现服务端并发
	//创建端点
	int sfd=socket(AF_INET,SOCK_STREAM,0);
	//参数1表示使用ipv4通信域
	//参数2表示使用TCP面向连接的通信方式
	//参数3表示补充通信协议，由于第二个参数已经指定通信方式，故写0
	if(sfd==-1){
		perror("socket");
		return 1;
	}
	else{
		printf("创建端点成功\n");
	}
	//将套结文件与IP地址与端口绑定
	struct sockaddr_in ip_port;
	char* ip="192.168.176.130";
	uint16_t port=9999;
	ip_port.sin_family=AF_INET;
	ip_port.sin_port=htons(port);
	ip_port.sin_addr.s_addr=inet_addr(ip);
	int retbind=bind(sfd,(struct sockaddr*)&ip_port,sizeof(ip_port));
	if(retbind==-1){
		perror("bind");
		return 1;
	}
	else if(retbind==0){
		printf("端口和IP绑定成功\n");
	}
	//将套接字设置为被动监听模式
	int retlisten=listen(sfd,128);
	if(retlisten==-1){
		perror("listen");
		return 1;
	}
	else if(retlisten==0){
		printf("设置监听成功\n");
	}
	//阻塞等待客户端连接
	struct sockaddr_in ser_ip_port;
	socklen_t addrlen=sizeof(ser_ip_port);
	while(1){
		int retaccept=accept(sfd,(struct sockaddr*)&ser_ip_port,&addrlen);
		if(retaccept==-1){
			perror("accept");
			return 1;
		}
		else{
			printf("客户端连接成功\n");
			printf("客户端IP：%s 客户端端口：%d\n",inet_ntoa(ser_ip_port.sin_addr),ntohs(ser_ip_port.sin_port));
		}
		int inter_parameter=retaccept;
		pthread_t id;
		int retpthread_create=pthread_create(&id,0,interaction,&inter_parameter);
		if(retpthread_create!=0){
			perror("pthread_creat");
			return -1;
		}
		pthread_detach(id);
	}
		close(sfd);
	return 0; 
}
void* interaction(void* arg){
 	//与客户端相互通信
	//解析arg
	int retaccept=*(int*)arg;
 	char wbuf[128]={0};
	char rbuf[128]={0};
	while(1){
		bzero(wbuf,0);
     	bzero(rbuf,0);                                        
		int retread=read(retaccept,rbuf,128);
		if(retread==0){//套结断开连接
			printf("客户端断开连接\n");
			break;
		}
 	printf("读取客户端内容：%s\n",rbuf);
	strcat(rbuf,"<服务端已成功读取>");
	write(retaccept,rbuf,128);
	printf("成功回复客服端\n");
	}
	close(retaccept);
	pthread_exit(NULL);
}

多点通信——广播发送端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//发送端实现
	//创建套接文件
	int rtsocket=socket(AF_INET,SOCK_DGRAM,0);
	if(rtsocket==-1){
		perror("socket");
		return -1;
	}
	else{
		printf("creat success\n");
	}
	//设置属性允许发送广播数据
	int res=-1;
	int reslen=sizeof(res);
	int rtgetsockopt=getsockopt(rtsocket,SOL_SOCKET,SO_BROADCAST,&res,&reslen);
	if(rtgetsockopt==-1){
		perror("getsockopt");
		return -1;
	}
	else{
		printf("res=%d\n",res);
	}
	int reluse=1;
	int rtsetsockopt=setsockopt(rtsocket,SOL_SOCKET,SO_BROADCAST,&reluse,sizeof(reluse));
	if(rtsetsockopt==-1){
		perror("setsockopt");
		return -1;
	}
	getsockopt(rtsocket,SOL_SOCKET,SO_BROADCAST,&res,&reslen);
	if(rtgetsockopt==-1){
		perror("getsockopt");
		return -1;
	}
	else{
		printf("res=%d\n",res);
	}
	//绑定ipyu端口(可选)
	//向广播发送消息
	struct sockaddr_in rin;
	char* bip="192.168.176.255";
	uint16_t bport=6666;                 
	rin.sin_family=AF_INET;
	rin.sin_port=htons(bport);
	rin.sin_addr.s_addr=inet_addr(bip);
	char wbuf[128]={0};
	while(1){
		bzero(wbuf,128);
		fgets(wbuf,128,stdin);
		wbuf[strlen(wbuf)-1]=0;
		ssize_t rtsendto=sendto(rtsocket,wbuf,sizeof(wbuf),0,(struct sockaddr*)&rin,sizeof(rin));
		if(rtsendto==-1){
			perror("sendto");
			return -1;
		}
		if(strcmp(wbuf,"over")==0){break;}
	}
	close(rtsocket);
	return 0;
}

多点通信——广播接收端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//接收端实现
	//创建套接文件
	int rtsocket=socket(AF_INET,SOCK_DGRAM,0);
	if(rtsocket==-1){
		perror("socket");
		return -1;
	}
	//填充结构体信息
	struct sockaddr_in rin;
	char* bip="192.168.176.255";
	uint16_t bport=6666;
	rin.sin_family=AF_INET;
	rin.sin_port=htons(bport);
	rin.sin_addr.s_addr=inet_addr(bip);
	//绑定广播端口号和IP（必须绑定）
	int rtbind=bind(rtsocket,(struct sockaddr*)&rin,sizeof(rin));
	if(rtbind==-1){
		perror("bind");
		return -1;
	}
	//接收广播信息
	char rbuf[128]={0};
	while(1){
		memset(rbuf,0,128);
		ssize_t rtrecv=recv(rtsocket,rbuf,sizeof(rbuf),0);
		if(rtrecv==-1){
			perror("recv");
			return -1;
		}
		printf("广播消息%s\n:",rbuf);
		if(strcmp(rbuf,"over")==0){break;}
	}
	close(rtsocket);
	return 0;
}

多点通信——组播接收端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//使用组播通信方式实现接收端
	int rtsocket=socket(AF_INET,SOCK_DGRAM,0);
	if(rtsocket==-1){
		perror("socket");
		return -1;
	}
	//将套接字加入多播组
	struct ip_mreqn ip_m;
	ip_m.imr_multiaddr.s_addr=inet_addr("224.1.2.3");
	ip_m.imr_address.s_addr=inet_addr("192.168.176.130");
	ip_m.imr_ifindex=2;
	int rtsetsockopt=setsockopt(rtsocket,IPPROTO_IP,IP_ADD_MEMBERSHIP,&ip_m,sizeof(ip_m));
	if(rtsetsockopt==-1){
		perror("setsockopt");
		return -1;
	}
	//填充地址信息结构体 
	struct sockaddr_in rin;
	rin.sin_family=AF_INET;
	uint16_t rport=5555;
	rin.sin_port=htons(rport);
	rin.sin_addr.s_addr=inet_addr("224.1.2.3");
	//绑定（必须）
	int rtbind=bind(rtsocket,(struct sockaddr*)&rin,sizeof(rin));
	if(rtbind==-1){
		perror("bind");
		return -1;
	}
	//接收消息
	char rbuf[128]={0};
	while(1){
		bzero(rbuf,128);
		int rtrecv=recv(rtsocket,rbuf,sizeof(rbuf),0);
		if(rtrecv==-1){
			perror("recv");
			return -1;
		}
		printf("接收的消息:%s\n",rbuf);
		if(strcmp(rbuf,"over")==0){break;}
	}
	close(rtsocket);
	return 0;
}

多点通信——组播发送端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//组播发送端
	int rtsocket=socket(AF_INET,SOCK_DGRAM,0);
	if(rtsocket==-1){
		perror("socket");
		return -1;
	}
	struct sockaddr_in sin;
	sin.sin_family=AF_INET;
	sin.sin_port=htons(5555);
	sin.sin_addr.s_addr=inet_addr("224.1.2.3");
	char wbuf[128]={0};
	while(1){
		memset(wbuf,0,128);
		fgets(wbuf,sizeof(wbuf),stdin);
		wbuf[strlen(wbuf)-1]=0;
		ssize_t rtsendto=sendto(rtsocket,wbuf,sizeof(wbuf),0,(struct sockaddr*)&sin,sizeof(sin));
		if(rtsendto==-1){
			perror("sendto");
			return -1;
		}
		printf("发送成功\n");
		if(strcmp(wbuf,"over")==0){break;}
	}
	close(rtsocket);
	return 0;
}
u

流式域套接字——服务端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//使用域套接创建服务端
	//创建端点
	int sfd=socket(AF_UNIX,SOCK_STREAM,0);
	//参数1表示使用域套接通信域
	//参数2表示使用TCP面向连接的通信方式
	//参数3表示补充通信协议，由于第二个参数已经指定通信方式，故写0
	if(sfd==-1){
		perror("socket");
		return 1;
	}
	else{
		printf("创建端点成功\n");
	}
	//判断套接文件是否存在，因为存在再重新创建并绑定会报错
	if(access("./unix",F_OK)==0){
		unlink("./unix");//存在则删除文件
	}
	//删除后，将套结文件与通信域与套接文件路径绑定
	struct sockaddr_un un;
	un.sun_family=AF_UNIX;
	strcpy(un.sun_path,"./unix");
	int retbind=bind(sfd,(struct sockaddr*)&un,sizeof(un));
	if(retbind==-1){
		perror("bind");
		return 1;
	}
	else if(retbind==0){
		printf("端口和IP绑定成功\n");
	}
	//将套接字设置为被动监听模式
	int retlisten=listen(sfd,128);
	if(retlisten==-1){
		perror("listen");
		return 1;
	}
	else if(retlisten==0){
		printf("设置监听成功\n");
	}
	//阻塞等待客户端连接 
	struct sockaddr_un sun;
	socklen_t addrlen=sizeof(sun);
	int retaccept=accept(sfd,(struct sockaddr*)&sun,&addrlen);
	if(retaccept==-1){
		perror("accept");
		return 1;
	}
	else{
		printf("客户端连接成功\n");
		printf("套接文件：[%s]\n",sun.sun_path);
	}
	//与客户端相互通信
	char wbuf[128]={0};
	char rbuf[128]={0};
	while(1){
		bzero(wbuf,0);
		bzero(rbuf,0);
		int retread=read(retaccept,rbuf,128);
		if(retread==0){//套结断开连接
			printf("客户端断开连接\n");
			break;
		}
		printf("读取客户端内容：%s\n",rbuf);
		strcat(rbuf,"<服务端已成功读取>");
		write(retaccept,rbuf,128);
		printf("成功回复客服端\n");
	}
	close(retaccept);
	close(sfd);

	return 0;
}

流式域套接字——客户端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//使用域套接创建一个客户端
	//创建端点
	int sfd=socket(AF_UNIX,SOCK_STREAM,0);
	if(sfd==-1){
		perror("socket");
		return 1;
	}
	else{
		printf("创建成功\n");
	}
	//判断文件是否存在 
	if(access("./lunix",F_OK)==0){
		unlink("./lunix");//存在则删除文件
	}
	//将套结文件绑定
	struct sockaddr_un un;
	un.sun_family=AF_UNIX;
	strcpy(un.sun_path,"./lunix");
	int retbind=bind(sfd,(struct sockaddr*)&un,sizeof(un));
	if(retbind==-1){
		perror("bind");
		return 1;
	}
	else if(retbind==0){
		printf("IP与端口绑定成功\n");
	}
	//与服务器连接
	struct sockaddr_un run;
	run.sun_family=AF_UNIX;
	strcpy(run.sun_path,"./unix");//填充需要发送服务端的套接文件
	int retconnect=connect(sfd,(struct sockaddr*)&run,sizeof(run));
	if(retconnect==-1){
		perror("connect");
		return 1;
	}
	else if(retconnect==0){
		printf("连接成功\n");
	}
	//与服务器相互通信
	char rbuf[128]={0};
	char wbuf[128]={0};
	while(1){
		memset(rbuf,0,128);
		memset(wbuf,0,128); 
		printf("请向服务端发送信息：");
		fgets(wbuf,128,stdin);
		wbuf[strlen(wbuf)-1]=0;
		send(sfd,wbuf,sizeof(wbuf),0);
		printf("向服务端发送消息成功\n");
		ssize_t retrecv=recv(sfd,rbuf,128,0);
		printf("接受服务端信息：%s\n",rbuf);
	}
	close(sfd);
	return 0;
}

报式域套接字——服务端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//使用域套接创建服务端
	//创建一个端点
	int retsocket=socket(AF_UNIX,SOCK_DGRAM,0);
	if(retsocket==-1){
		perror("socket");
		return -1;
	}
	else{
		printf("创建端点成功\n");
	}
	//判断要绑定的套接文件是否存在，存在则删除（存在文件再重新绑定会报错）
	if(access("./udpunix",F_OK)==0){
		unlink("./udpunix");//存在则删除
	}
	//绑定套接字文件
	struct sockaddr_un un;
	un.sun_family=AF_UNIX;
	strcpy(un.sun_path,"./udpunix");
	int retbind=bind(retsocket,(struct sockaddr*)&un,sizeof(un));
	if(retbind==-1){
		perror("bind");
		return -1;
	}
	else if(retbind==0){
		printf("绑定成功\n");
	}
	//与客服端相互通信
	struct sockaddr_un sun;
	char rbuf[128]={0};
	char wbuf[128]={0};
	socklen_t addrlen=sizeof(sun);
	while(1){
		bzero(rbuf,0);
		bzero(wbuf,0);
		ssize_t retrecvfrom=recvfrom(retsocket,rbuf,128,0,(struct sockaddr*)&sun,&addrlen);
		if(retrecvfrom==-1){
			perror("recvfrom");
			return -1;
		}
		else{
			printf("读取客服端消息成功\n");
			printf("读取客服端消息：%s\n",rbuf);
		}
		//判断消息内容，只与一个人连接
		if(strcmp(rbuf,"connect")==0){
			connect(retsocket,(struct sockaddr*)&sun,sizeof(sun));
		}
		else if(strcmp(rbuf,"disconnect")==0){//断开连接
			sun.sun_family=AF_UNSPEC;
			connect(retsocket,(struct sockaddr*)&sun,sizeof(sun));
		}
		printf("请向客服端发送消息\n");
		fgets(wbuf,128,stdin);
		wbuf[strlen(wbuf)-1]=0;//清除空格
		ssize_t retsendto=sendto(retsocket,wbuf,strlen(wbuf),0,(struct sockaddr*)&sun,addrlen);
		if(retsendto==-1){
			perror("sendto");
			return -1;
		}
		else{
			printf("向客服端发送消息成功\n"); 
		}
	}
	close(retsocket);
	return 0;
}

报式域套接字——客户端实现：

#include<head.h>
int main(int argc, const char *argv[])
{
	//创建客服端
	//创建一个端点，即套接字文件
	int retsocket=socket(AF_UNIX,SOCK_DGRAM,0);
	if(retsocket==-1){
		perror("socket");
		return -1;
	}
	else{
		printf("创建端点成功\n");
	}
	 //判断要绑定的套接文件是否存在，存在则删除（存在文件再重新绑定会报错）
 	if(access("./ludpunix",F_OK)==0){
		unlink("./ludpunix");//存在则删除
 	}

	//使套接字绑定
	struct sockaddr_un un;
	un.sun_family=AF_UNIX;
	strcpy(un.sun_path,"./ludpunix");
	int retbind=bind(retsocket,(struct sockaddr*)&un,sizeof(un));
	if(retbind==-1){
		perror("bind");
		return -1;
	}
	else if(retbind==0){
		printf("绑定成功\n");
	}
	//与服务端相互通信
	struct sockaddr_un serun;
	serun.sun_family=AF_UNIX;
	strcpy(serun.sun_path,"./udpunix");
	char rbuf[128]={0};
	char wbuf[128]={0};
	socklen_t addrlen=sizeof(serun);
	while(1){
		bzero(rbuf,0);
		bzero(wbuf,0);
		printf("请向服务端发送消息\n");
		fgets(wbuf,128,stdin);
		wbuf[strlen(wbuf)-1]=0;//清除空格
		ssize_t retsendto=sendto(retsocket,wbuf,strlen(wbuf),0,(struct sockaddr*)&serun,addrlen);
		if(retsendto==-1){
			perror("sendto");
			return -1;
		}
		ssize_t retrecv=recvfrom(retsocket,rbuf,128,0,(struct sockaddr*)&serun,&addrlen);
		if(retrecv==-1){
			perror("sendto");
			return -1;
		}
		else{
			printf("读取服务端消息成功\n");
			printf("读取服务端消息：%s\n",rbuf);
		}
	}
	close(retsocket);
	return 0;
}

DJQ2020391635
关注
网络编程（TCP/IP协议/套接字等）
daidadeguaiguai的博客
02-06 1326
文章目录 01、网络通信概述 02、TCP/IP协议 03、socket编程 04、socket中的TCP与UDP 05、并发服务器 01、网络通信概述 1、什么是网络？ 简单意义上来说，网络就是⼀种辅助双⽅或者多⽅能够连接在⼀起的⼯具。 官方对于网络的定义为： 网络是由若干节点和连接这些节点的链路构成，表示诸多对象及其相互联系。 在1999年之前，人们一般认为网络的...
tcp并发通信
04-16
在linux中，采用C语言实现网络通信，本次通信采用tcp模式，使用select函数实现并发通信
TCP服务端实现并发
Waller_的博客
08-14 235
socket 在 tcp 协议下通信 客户端 import socket ​ # 创建客户端TCP协议通信 c = socket.socket() # 与指定服务端握手 c.connect(('127.0.0.1', 8080)) ​ # 通信循环 while True: # 向服务端发送信息 msg = input('>>>') if len...
TCP 通信程序示例——实现一个服务器连接多个客户端
最新发布
weixin_63556308的博客
09-03 1505
这段代码实现了一个简单的 TCP 服务器，它在本地回环地址的 50000 端口上监听客户端连接请求。当有客户端连接时，服务器会创建一个子进程来处理与该客户端的通信。子进程会接收客户端发送的数据，并在数据后加上当前时间后发送回客户端。同时，服务器还注册了一个信号处理函数来处理子进程结束的信号，以防止产生僵尸进程。
TCP并发服务器（多进程与多线程）
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
02-20 2216
多线程及多进程版本的TCP并发服务器实现。
TCP并发服务器（多线程）
augeksjsj的博客
01-05 684
每连接一个客户端都创建一个子线程去处理信息，线程设置成分离态，线程结束系统自动回收资源。线程处理函数中不能使用exit函数。./可执行程序名 +IP地址+端口号。
协程-基于TCP的高并发通信
weixin_30247159的博客
08-31 86
from gevent import monkey;monkey.patch_all() from socket import * import gevent def sever(ipport): s = socket(AF_INET,SOCK_STREAM) s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) s.bind(...
MODBUS-TCP规范
04-14
- **主要用途**：服务于PLC（可编程逻辑控制器）、I/O模块等自动化设备之间的通信，以及与其他简单域总线或I/O模块的网关服务。 #### 二、面向连接与数据编码 **面向连接**： - **传统数据处理方式**：在MODBUS中...
Linux网络编程：UDP套接字与应用场景
此外，文档还概述了Linux套接字网络编程接口的发展历史和实现方式，包括面向连接和无连接的套接字编程、高级套接字函数、服务器的I/O模型，以及更低层次的网络和数据链路层套接字编程。” 在Linux网络编程中，UDP...
TCP/IP Socket编程：创建套接字详解
在计算机网络通信中，套接字（Socket）是实现进程间通信的重要工具，特别是在TCP/IP协议栈上。创建套接字是进行Socket编程的第一步，通常由`socket()`函数完成。这个函数定义在`<sys/socket.h>`头文件中，其语法如下...
网络编程（tcp和udp）
Cocobuhui的博客
11-03 319
网络编程（tcp和udp）
128-网络编程：TCP通信的并发（多进程实现并发服务器）
Edward_LF的博客
05-02 3059
3、TCP通信的并发（多进程实现并发服务器） 3.1 多进程实现并发服务器 要实现TCP通信服务器处理并发任务，使用多线程或者多进程来解决。 思路: 1. 一个父进程，多个子进程 2. 父进程负责等待并接受客户端连接 3. 子进程: 完成通信，接受一个客户端连接，就创建一个子进程用于通信。 #include <stdio.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.
网络编程--TCP通信并发版C/S
junaozun的博客
05-22 380
上一篇文章实现了的是单次通信，且一个服务器只能连接一个客户端。这里使用goroutine实现并发版的，可以实现多个客户端连接服务器，实现并发请求。示意图如下： server端代码： package main import ( "fmt" "net" "strings" ) func main() { //指定服务器通信协议、IP地址、Port端口，创建一个用于监听的sock...
TCP并发服务器模型（1）
sinat_27180563的博客
03-19 229
1、统一accept，fork进程处理每一个客户端的业务 2、统一accept，create线程处理每一个客户端的业务 3、创建线程处理每一个客户端的请求，互斥处理每一个accept ...
tcp并发总结
weixin_46539107的博客
10-29 128
实现TCP并发服务器
weixin_47783699的博客
11-25 2702
详解实现TCP并发服务器两种方法:1、使用多进程实现TCP并发服务器2、使用多线程实现TCP并发服务器。
简单的，使用套接字实现TCP通信（用线程实现并发）
FunkyFrog821951259的博客
12-10 1454
#include #include #include #include #include #include #define N 100 #define PORT 8000 void *func(void *argv) { int connectfd = (int)argv; char msg[N]; int n; int i; while(1) { n = rec
TCP 通信并发服务器详解（附有案例代码）
热爱数据库的小胖
07-20 2706
代码】TCP通信并发详解（附有案例代码）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值