2022/11/26 IO多路复用select，poll，TCP文件传输项目

已于 2022-11-27 23:22:57 修改
阅读量401 收藏
点赞数
文章标签： tcp/ip 网络协议 网络
于 2022-11-27 22:35:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyangnan/article/details/128049822
版权

select服务端

#include <stdio.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <errno.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#define PORT 6666
#define IP "192.168.8.66"
int main(int argc, const char *argv[])
{
	int sfd;
	if((sfd=socket(AF_INET,SOCK_STREAM,0))<0)//创建流式套接字
	{
		perror("scoket");
		return -1;
	}
	int reuse=1;
	if(setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))<0)
	{
		perror("setsockopt");
		return -1;
	}
	struct sockaddr_in sin;
	sin.sin_family=AF_INET;
	sin.sin_port=htons(PORT);//端口号的网络字节序
	sin.sin_addr.s_addr=inet_addr(IP);//IP号的网络字节序
	if(bind(sfd,(struct sockaddr *)&sin,sizeof(sin))<0)
	{
		perror("bind");
		return -1;
	}

	if(listen(sfd,128)<0)//把套接字设置为监听状态
	{
		perror("listen");
		return -1;
	}
	printf("%d",sfd);
	//创建一个读集合
	fd_set readfds;
	fd_set tempfds;//中间集合
	//清空集合
	FD_ZERO(&readfds);
	FD_ZERO(&tempfds);
	//将需要的文件描述符加到集合中
	FD_SET(0,&readfds);
	FD_SET(sfd,&readfds);
	int maxfd=sfd;//最大文件描述符

	struct sockaddr_in cin;
	char buf[128]="";
	int s_res=0;
	int newfd=0;;
	socklen_t len=sizeof(cin);
	ssize_t res=0;
	struct sockaddr_in tin[1020];
	while(1)
	{
		tempfds=readfds;
		if((s_res=select(maxfd+1,&tempfds,NULL,NULL,NULL))<0)//监测中
		{
			perror("select");
			return -1;
		}

		for(int i=0;i<=maxfd;i++)
		{
			if(FD_ISSET(i,&tempfds)==0)
			{
				continue;
			}

			if(0==i)
			{
				int sendfd;
				int ret;
				printf("触发键盘输入事件\n");
				ret=scanf("%d %s",&sendfd,buf);
				while(getchar()!=10);
				if(ret!=2)
				{
					printf("请重新校验格式\n");
					continue;
				}
				if(strcmp(buf,"quit")==0)
				{
					exit(0);
				}
				if(sendfd>sfd&&FD_ISSET(sendfd,&readfds))
				{
					if(send(sendfd,buf,sizeof(buf),0)<0)
					{
						perror("send");
						return -1;
					}
					printf("发送成功\n");
				}
				else
				{
					printf("该端口不可用\n");
				}
			}

			else if(i==sfd)
			{
				printf("触发客户端连接事件\n");
				if((newfd=accept(sfd,(struct sockaddr *)&cin,&len))<0)//创建新的套接字用来通信
				{
					perror("accept");
					return -1;
				}
				printf("连接成功newfd=%d\n",newfd);
				FD_SET(newfd,&readfds);
				maxfd=(maxfd>newfd?maxfd:newfd);
				tin[newfd-4]=cin;
			}
			else
			{
				bzero(buf,sizeof(buf));
				if((res=recv(i,buf,sizeof(buf),0))<0)
				{
					perror("recv");
					return -1;
				}
				else if(0==res)
				{
					printf("客户端关闭\n");
					FD_CLR(i,&readfds);
					close(i);
					for(int j=maxfd;j>0;j--)
					{
						if(FD_ISSET(j,&readfds))
						{
							maxfd=j;
							break;
						}
					}
				}
				printf("port=%d %s\n",ntohs(tin[i-4].sin_port),buf);
			}
		}

	}
	close(sfd);
	close(newfd);
	return 0;
}

 select客户端

#include <sys/types.h>          
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/time.h>
#define SERPORT 6666
#define SERIP "192.168.8.66"
int main(int argc, const char *argv[])
{
	int sfd;
	if((sfd=socket(AF_INET,SOCK_STREAM,0))<0)//创建流式套接字
	{
		perror("scoket");
		return -1;
	}
 
	struct sockaddr_in cin;
	cin.sin_family=AF_INET;//服务器的
	cin.sin_port=htons(SERPORT);//端口号的网络字节序
	cin.sin_addr.s_addr=inet_addr(SERIP);//IP号的网络字节序
	
	if(connect(sfd,(struct sockaddr *)&cin,sizeof(cin))<0)//建立连接
	{
		perror("connect");
		return -1;
	}
	//创建集合
	fd_set readfds,tempfds;
	FD_ZERO(&readfds);
	FD_SET(sfd,&readfds);
	FD_SET(0,&readfds);
	int maxfd=sfd;
	
	ssize_t res;
	char buf[128]="";
	int ret;
	while(1)
	{
		tempfds=readfds;
		//select监测
		ret=select(maxfd+1,&tempfds,NULL,NULL,NULL);
		if(ret<0)
		{
			perror("select");
			return -1;
		}
		else if(0==ret)
		{
			printf("timeout\n");
			return -1;
		}
		if(FD_ISSET(sfd,&tempfds))
		{
			res=recv(sfd,buf,sizeof(buf),0);//接收
			if(res<0)
			{
				perror("recv");
				return -1;
			}
			else if(0==res)
			{
				printf("服务端关闭\n");
				break;
			}
			printf("%s\n",buf);

		}
		if(FD_ISSET(0,&tempfds))
		{
			bzero(buf,sizeof(buf));//发送
			printf("请输入>>>");
			scanf("%s",buf);
			while(getchar()!=10);
			if(send(sfd,buf,sizeof(buf),0)<0)
			{
				perror("send");
				return -1;
			}
			printf("发送成功\n");
		}
	}
	close(sfd);
	return 0;
}

poll客户端

#include <stdio.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <errno.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <poll.h>

#define SERPORT 6666
#define SERIP "192.168.8.66"
int main(int argc, const char *argv[])
{
	int sfd;
	if((sfd=socket(AF_INET,SOCK_STREAM,0))<0)//创建流式套接字
	{
		perror("scoket");
		return -1;
	}
 
	struct sockaddr_in cin;
	cin.sin_family=AF_INET;//服务器的
	cin.sin_port=htons(SERPORT);//端口号的网络字节序
	cin.sin_addr.s_addr=inet_addr(SERIP);//IP号的网络字节序
	
	if(connect(sfd,(struct sockaddr *)&cin,sizeof(cin))<0)//建立连接
	{
		perror("connect");
		return -1;
	}
	struct pollfd fds[2];//创建集合
	fds[0].fd=0;
	fds[0].events=POLLIN;//监测读事件
	fds[1].fd=sfd;
	fds[1].events=POLLIN;
	
	ssize_t res;
	char buf[128]="";
	int ret;
	while(1)//内核循环监测
	{
		ret=poll(fds,2,-1);
		if(ret<0)
		{
			perror("poll");
			return -1;
		}
		else if(0==ret)
		{
			printf("timeout\n");
		}
		//能运行到此处，代表结束阻塞有事件产生
		if(fds[0].revents&POLLIN)
		{
			bzero(buf,sizeof(buf));//发送
			printf("请输入>>>");
			scanf("%s",buf);
			while(getchar()!=10);
			if(send(sfd,buf,sizeof(buf),0)<0)
			{
				perror("send");
				return -1;
			}
			printf("发送成功\n");
		}

		if(fds[1].revents&POLLIN)
		{
			res=recv(sfd,buf,sizeof(buf),0);//接收
			if(res<0)
			{
				perror("recv");
				return -1;
			}
			else if(0==res)
			{
				printf("客户端关闭\n");
				break;
			}
			printf("%s\n",buf);
		}
	}
	close(sfd);
	return 0;
}

项目

服务端

#include <stdio.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <errno.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <pthread.h>
#include <netinet/in.h>
#include <dirent.h>
#include <sys/stat.h>
#include <fcntl.h>

#define PORT 6666
#define IP "192.168.8.66"
struct msg
{
	int newfd;
	struct sockaddr_in sin;
};
char buf[516]="";
void *callback(void*arg);//线程执行体
int upload(int newfd);
int download(int newfd);
int seedir(int newfd);
int main(int argc, const char *argv[])
{
	
	struct msg info;
	int sfd,newfd;
	if((sfd=socket(AF_INET,SOCK_STREAM,0))<0)//创建流式套接字
	{
		perror("scoket");
		return -1;
	}
	int reuse=1;
	setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse));
	struct sockaddr_in sin;
	sin.sin_family=AF_INET;
	sin.sin_port=htons(PORT);//端口号的网络字节序
	sin.sin_addr.s_addr=inet_addr(IP);//IP号的网络字节序
	if(bind(sfd,(struct sockaddr *)&sin,sizeof(sin))<0)
	{
		perror("bind");
		return -1;
	}

	if(listen(sfd,128)<0)//把套接字设置为监听状态
	{
		perror("listen");
		return -1;
	}
	struct sockaddr_in cin;//存储连接成功的客户端信息
	socklen_t addrlen=sizeof(cin);
	pthread_t tid;
	while(1)
	{
		if((newfd=accept(sfd,(struct sockaddr *)&cin,&addrlen))<0)//创建新的套接字用来通信
		{
			perror("accept");
			return -1;
		}
		info.newfd=newfd;//结构体赋值
		info.sin=cin;
		printf("[%s:%d] newfd=%d,连接成功\n",\
				inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd);
		if(pthread_create(&tid,NULL,callback,(void*)&info)<0)
		{
			perror("pthread_create");
			return -1;
		}
	}
	close(sfd);
	return 0;
}
void *callback(void*arg)//线程执行体
{
	pthread_detach(pthread_self());//线程分离
	ssize_t res;
	int newfd=((struct msg*)arg)->newfd;
	while(1)
	{
		//接收客户端的请求信息
		res=recv(newfd,buf,sizeof(buf),0);
		if(0==res)
		{
			printf("客户端已经关闭\n");
			close(newfd);
			return NULL;
		}
		else if(res<0)
		{
			perror("recv");
			return NULL;
		}

		//跳转到对应的功能
		switch(buf[1])
		{
		case 1:
			download(newfd);
			break;
		case 2:
			printf("%s\n",buf+2);
			upload(newfd);
			break;
		case 3:
			seedir(newfd);
			break;
		default:
			break;
		}
	}
}
int upload(int newfd)
{
	ssize_t res;
	int fd;
	umask(0);
	fd=open(buf+2,O_WRONLY|O_CREAT|O_TRUNC,0777);
	if(fd<0)
	{
		perror("open");
	}
	*(unsigned short*)buf=htons(5);//操作码
	*(unsigned short*)(buf+2)=htons(0);//块编号
	if(send(newfd,buf,4,0)<0)//发送ACK
	{
		perror("send");
		return -1;
	}
	unsigned short num=1;
	while(1)
	{
		bzero(buf,sizeof(buf));
		res=recv(newfd,buf,sizeof(buf),0);//接收数据包
		if(res<0)
		{
			perror("recv");
			return -1;
		}
		if(5==buf[1])
		{
			if(htons(num)==*(unsigned short*)(buf+2))//校验块编号
			{
				write(fd,buf+4,res-4);
				if(res<0)
				{
					perror("write");
					return -1;
				}
				else if(0==res)
				{
					printf("文件上传完毕\n");
					break;
				}
                num++;	
			}
		}
		if(send(newfd,buf,4,0)<0)//发送ACK
		{
			perror("send");
			return -1;
		}
	}
	close(fd);
}
int download(int newfd)
{
	ssize_t res;
	int fd;
	printf("%s\n",buf+2);
	fd=open(buf+2,O_RDONLY);
	if(fd<0)
	{
		perror("open");
		*(unsigned short*)buf=htons(6);
		if(send(newfd,buf,2,0)<0)
		{
			perror("sdownload_send");
			return -1;
		}
		return -1;
	}
	unsigned short num=1;
	while(1)
	{
		bzero(buf,sizeof(buf));
		*(unsigned short*)buf=htons(4);//操作码
		*(unsigned short*)(buf+2)=htons(num);//块编号
		res=read(fd,buf+4,sizeof(buf)-4);
		printf("%ld\n",res);
		if(send(newfd,buf,res+4,0)<0)
		{
			perror("sdownload_send");
			return -1;
		}
		if(res<0)
		{
			perror("read");
			return -1;
		}
		else if(0==res)
		{
			printf("文件下载完毕\n");
			break;
		}
		//接收ACK
		recv(newfd,buf,4,0);
		if(htons(num)!=*(unsigned short*)(buf+2))
		{
			break;
		}
		num++;
	}
	close(fd);
}
int seedir(int newfd)
{
	DIR *dirp=opendir("./");
	bzero(buf,sizeof(buf));
	struct dirent *dir;
	while(dir!=NULL)
	{
		dir=readdir(dirp);
		if(NULL==dir)
		{
			break;;
		}
		strcat(buf,dir->d_name);
		buf[strlen(buf)]='\n';
	}
	if(send(newfd,buf,sizeof(buf),0)<0)
	{
		perror("send");
		return -1;
	}
}

客户端

#include <stdio.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <errno.h>
#include <sys/types.h>          
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#define PORT 6666
#define IP "192.168.8.66"
int upload(int sfd);
int download(int sfd);
int seedir(int sfd);
int main(int argc, const char *argv[])
{
	int sfd;
	if((sfd=socket(AF_INET,SOCK_STREAM,0))<0)//创建流式套接字
	{
		perror("scoket");
		return -1;
	}

	struct sockaddr_in cin;
	cin.sin_family=AF_INET;//服务器的
	cin.sin_port=htons(PORT);//端口号的网络字节序
	cin.sin_addr.s_addr=inet_addr(IP);//IP号的网络字节序

	if(connect(sfd,(struct sockaddr *)&cin,sizeof(cin))<0)//建立连接
	{
		perror("connect");
		return -1;
	}
	printf("连接成功\n");
	while(1)
	{
		system("clear");
		printf("|****************************|\n");
		printf("|*********1.下载*************|\n");
		printf("|*********2.上传*************|\n");
		printf("|*********3.查看目录*********|\n");
		printf("|*********4.退出*************|\n");
		printf("|****************************|\n");
		printf("请输入>>>");
		char c;
		c=getchar();
		while(getchar()!=10);
		switch(c)
		{
		case '1':
			download(sfd);
			break;
		case '2':
			upload(sfd);
			break;
		case '3':
			seedir(sfd);
			break;
		case '4':
			goto END;
			break;

		default:
			printf("输入错误，请重新输入\n");
		}
		printf("请输入任意字符清屏\n");
		while(getchar()!=10);
	}
END:
	close(sfd);
	return 0;
}
int upload(int sfd)
{
	char buf[516]="";
	char pathname[128]="";
	printf("请输入要上传的文件路径>>>");
	scanf("%s",pathname);
	while(getchar()!=10);
	int fd=open(pathname,O_RDONLY);//打开要上传的文件
	if(fd<0)
	{
		perror("fopen");
		return -1;
	}
	char filename[128]="";
	int i;
	int k=0;
	for(i=strlen(pathname);i>0;i--)
	{
		if(pathname[i]!='/')
		{
			k++;
		}
		else
		{
			break;
		}
	}
	strcpy(filename,pathname+(strlen(pathname)-k)+1);
	size_t res;
	int size=sprintf(buf,"%c%c%s",0,2,filename);//上传请求包
	if(send(sfd,buf,size,0)<0)
	{
		perror("send");
		return -1;
	}
	unsigned short num=0;
	int flag=0;
	while(1)
	{
		//接收ACK包
		if((recv(sfd,buf,sizeof(buf),0))<0)
		{
			perror("recv");
			return -1;
		}
		if(htons(num)==*(unsigned short*)(buf+2))
		{
			printf("%d %d\n",htons(num),*(unsigned short*)(buf+2));
			if(0==flag)
			{
				fd=open(filename,O_RDONLY);
				if(fd<0)
				{
					perror("open");
					return -1;
				}
				flag=1;
			}
			num++;
			bzero(buf,sizeof(buf));
			res=read(fd,buf+4,sizeof(buf)-4);
			printf("%ld\n",res);
			*(unsigned short*)buf=htons(5);//操作码
			*(short int*)(buf+2)=htons(num);//块编号
			if(send(sfd,buf,res+4,0)<0)
			{
				perror("send");
				return -1;
			}
			if(0==res)
			{
				break;
			}
			else if(res<0)
			{
				return -1;
			}
		}
	}
	close(fd);
}
int download(int sfd)
{
	ssize_t res;
	char buf[516]="";
	char filename[128]="";
	printf("请输入要下载的文件名>>>");
	scanf("%s",filename);
	while(getchar()!=10);
	int size=sprintf(buf,"%c%c%s",0,1,filename);//下载请求包
	if(send(sfd,buf,size,0)<0)
	{
		perror("send");
		return -1;
	}
	int flag=0;
	int fd;
	while(1)
	{
		bzero(buf,sizeof(buf));
		if((res=recv(sfd,buf,sizeof(buf),0))<0)
		{
			perror("recv");
			return -1;
		}
		if(0==flag)
		{
			fd=open(filename,O_WRONLY|O_CREAT|O_TRUNC,0777);
			if(fd<0)
			{
				perror("open");
				return -1;
			}
			flag=1;
		}
		int asd=write(fd,buf+4,res-4);
		printf("%ld %d\n",res,asd);
		//发送ACK包
		buf[1]=5;
		printf("%d\n",*(unsigned short*)(buf+2));
		if(send(sfd,buf,4,0)<0)
		{
			perror("send");
			return -1;
		}
		if(res<516&&res>=0)
		{
			break;
		}
	}
	close(fd);
}
int seedir(int sfd)
{
	char buf[516]="";
	int size=sprintf(buf,"%c%c",0,3);//查看请求包
	if(send(sfd,buf,size,0)<0)
	{
		perror("send");
		return -1;
	}
	bzero(buf,sizeof(buf));
	if(recv(sfd,buf,sizeof(buf),0)<0)
	{
		perror("recv");
		return -1;
	}
	printf("%s",buf);
}

skyangnan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一个select服务的文件传输
shashawangxing的专栏
09-27 824
<br />//服务器的代码  只能传输文本文件<br />#include <WinSock2.h><br />#include <stdio.h><br />#pragma comment (lib,"ws2_32.lib")<br />#define FILEFROMADDR "F://521.jpg"<br />void main()<br />{<br /> WORD wVersionRequested;<br /> WSADATA wsaData;<br /> int err;<br /> wV
select+单进程实现大文件传输
11-13
1.一个服务器程序能够同时接受多个客户端程序发送的数据，同时支持的客户端数量不少于100个； 2.客户端向服务器发送的数据内容是：自己的进程ID，以及文件data.txt中的内容，自己创建这个文件，内容随意； 3.服务器要把从每个客户端收到的数据记录到一个文件中，文件名字：recv.txt，每行包括一个进程ID和从相应客户端收到的文本内容； 4.服务器收到客户端发来的数据后，要向客户端发送确认信息； 5.客户端发送完数据后，需要等待服务器的确认或者做超时处理，超时时间可以配置，缺省3秒； 6.验证当服务器不向客户端发确认时，客户端是否能正确处理超时； 7.测试程序，启动100个客户端，同时向服务器发送数据。
C语言简单实现文件传输
weixin_45710519的博客
08-24 7132
为了实现文件传输，我们需要一个服务端跟一个客户端
Linux网络编程(三)——select函数实现I/O复用（传输文件）
van的博客
06-02 958
客户端 #include #include #include #include #include void error(char *er); #pragma comment(lib, "ws2_32.lib") //加载 ws2_32.dll int main(){ while (1) { char IP[100]; int port; //初始化DLL WSADATA w
用select或者selector实现文件的上传下载
淮南草的博客
06-26 946
要求实现文件上传下载 ，多并发，比如能演示出两个链接同时下载文件
多路复用IO：select、poll、epoll
baboon_chen
11-13 199
多路IO复用是指单个进程/线程就可以同时处理多个IO请求。用户将想要监视的文件描述符添加到selectpollepoll函数中，由内核监视，函数阻塞。一旦有文件描述符就绪(读就绪或写就绪)，或者超时(设置了超时时间)，函数就会返回，然后该进程可以进行相应的读/写操作。
I/O多路复用：select、poll和epoll详解
Tyler_Zx的博客
04-10 9799
I/O多路复用 I/O复用使得程序能同时监听多个文件描述符，这对提高程序的性能至关重要。通常，网络程序在下列情况下需要使用I/O复用技术： 客户端程序要同事处理多个socket。比如将讨论的非阻塞connect技术。 客户端程序要同时处理用户输入和网络连接。 TCP服务器要同时处理监听socket和连接socket。这是I/O复用使用最多的场合。 I/O复用虽然能同时监听多个文件描述...
C++中的IO多路复用（select、poll、epoll）总结
板栗的学习日常
02-16 2062
I/O多路复用（IO multiplexing）是一种并发处理多个I/O操作的机制。它允许一个进程或线程同时监听多个文件描述符（如套接字、管道、标准输入等）的I/O事件，并在有事件发生时进行处理。传统的I/O模型中，通常使用阻塞I/O和非阻塞I/O来处理单个I/O操作。如果需要同时处理多个I/O操作，那么需要使用多个线程或多个进程来管理和执行这些I/O操作。这种方式会导致系统资源的浪费，且编程复杂度较高。而I/O多路复用通过提供一个统一的接口，如select、poll、epoll。
2.1 网络io、io多路复用select/poll/epoll、基于事件驱动的reactor
Ricardo2的博客
05-31 1308
网络I/O请求是指在计算机网络中，向其他主机或服务器发送请求或接收响应的操作。这些请求可以包括获取网页、下载文件、发送电子邮件等。网络I/O请求需要使用合适的协议和通信方式来进行数据传输，例如HTTP、FTP、SMTP等。要完成一个完整的 TCP/IP 网络通信过程，需要使用一系列函数来实现。这些函数包括 bind、listen、accept 和 recv/send 等。对于第4步的请求，如果向下面方式处理，则只能接受一个客户端的请求。
IO 多路复用 之 (select/poll/epoll)
李俊的博客
05-04 379
一、常见的IO模型 IO模型主要分为同步IO和异步IO两大类，同步IO和异步IO主要区别 同步IO: 当进程发起IO操作后，数据准备就绪做真实IO操作的时候，这个过程是阻塞的 异步IO： 当进程发起IO 操作之后，就直接返回，直到kernel发送一个信号，告诉进程IO操作完成，无需进程负责真实IO操作，所以不存在阻塞，称之为异步 同步IO模型（synchronous IO） 阻塞IO（bloking IO） 非阻塞IO（non-blocking IO） 多路复用IO（multiplex..
IO多路复用之select_poll_epoll详解1
08-04
IO多路复用通过系统调用如select、poll、epoll等，让程序可以监控多个文件描述符（通常包括网络套接字）。当其中任一描述符准备好进行读写操作时，系统会通知程序。这种机制在处理多个客户端连接时非常有效，避免了...
TCP服务器IO模型之多路复用（一）POLL函数.zip
09-20
总的来说，TCP服务器的多路复用IO模型通过POLL函数，有效地解决了高并发场景下服务器性能的问题，提升了服务的响应速度和系统资源利用率。在实际开发中，理解并熟练掌握POLL函数的使用对于构建高效、稳定的网络服务...
tcp 网络编程select()/poll()实现io多路复用，
qishang_62的博客
02-24 451
用select实现tcp协议服务器 一个线程只能处理一个套接字的I/O事件，如果想同时处理多个，可以利用非阻塞忙轮询的方式 select/poll可以同时监察多个流的i/o事件 #include &lt;stdio.h&gt; #include &lt;sys/types.h&gt; #include &lt;sys/stat.h&gt; #include &lt;fcntl.h&gt; ...
【Redis】IO多路复用 及 Select、Poll、Epoll、NIO
火火的博客
12-17 1961
文章目录文件事件处理器【I/O多路复用程序】的实现文件事件的处理器连接应答处理器：命令请求处理器：命令回复处理器一次完整的客户端与服务器链接示例 文件事件处理器 Redis开发了一个文件事件处理器，文件事件处理器使用I/O多路复用（multiplexing）程序来同时监听多个套接字， 并根据套接字目前执行的任务来为套接字关联不同的事件处理器。 当被监听的套接字准备好执行 连接应答（accept）、读取（read）、写入（write）、关闭（close）等操作时， 与操作相对应的文件事件就会产生，此时，文件事
Linux下I/O多路复用(select、poll、epoll)，含函数解析及注意要点 ，干货满满！！
C__YUE的博客
03-24 1133
liunx下基于c/c++的网络编程中的I/O多路复用（select、poll、epoll）介绍。 select是 Linux 原生的、可跨平台的多路复用技术 poll在 Linux 系统中常被用于高并发网络服务器编程 epoll是一种优于poll的 I/O 多路复用机制，在 Linux 系统中常被用于高并发网络服务器编程；epoll 使用eopll_event 通过epoll_create、epoll_ctl 和 epoll_wait 这三个系统调用来实现事件多路转接。 #多路复用#多路复用#多路复用
Linux系统编程（14）UDP全双工通信和TCP半双工通信
weixin_68239724的博客
08-22 948
listen函数将创建的socket套接字设置为监听模式后，创建一个序列用来存储请求连接的设备，accept函数每次将第一个在队列中的请求进行处理后产生一个用来通信的和客户端建立连接的新的套接字 ，用来负责后续的通信。如果有更多的连接请求到达，新的连接可能会被拒绝或未处理，直到队列中有空闲位置。由于TCP面向连接和可靠性高的特性，因此，在使用TCP协议通信时，需要在客户端和服务端之间先建立连接才能进行数据通信。: 指定缓冲区的大小，即要接收的数据的最大字节数。结构体的指针，包含要绑定到的地址信息。
长效住宅IP——存在永久有效的住宅代理IP吗？如何获取？
roostertalking的博客
08-23 583
然而，由于互联网的性质，IP 地址往往会发生变化，尤其是对于家庭网络用户而言，这是因为互联网服务提供商经常重新分配 IP 地址以确保网络的安全性和稳定性。然而，在现实世界中，IP 地址是一种有限资源，需要分配、管理和维护，因此不存在真正永久有效的 IP 地址。但代理服务提供商可以为您提供稳定的住宅 IP 地址，并可根据您的需求进行轮换，以确保您能够持续访问特定的在线资源或执行特定的活动。在互联网架构中，IP 地址是有限的资源，会分配给不同的 ISP，并在需要时重新分配。可以分别选择静态/动态住宅IP代理，
TCP/UDP的对比，粘包分包抓包，http协议
xgshxjhs_的博客
08-23 1174
当我们在浏览器输入一个网址，此时浏览器就会给对应的服务器发送一个 HTTP 请求，对应的服务器收到这个请求之后，经过计算处理，就会返回一个 HTTP 响应。注意： 当我们访问一些网页时，是显示通过 HTTPS 来进行通信的，并且当下大多数的网页都是通过 HTTPS 来进行通信的，因为 HTTPS 在 HTTP 的基础上做了一个加密的工作。协议： 为了使数据在网络上从源头到达目的，网络通信的参与方必须遵循相同的规则，这套规则称为协议，它最终体现为在网络上传输的数据包的格式。（2）指定要发送的数据的长度。
【嵌入式开发之网络编程】TCP并发实现
最新发布
boy_ding_jian的博客
08-26 248
在实例中，经常会存在多个客户端向服务端发送连接请求和传递数据的情况，为了解决这个问题，我们需要利用或者来实现并发。
TCP状态转换与select、poll在IO多路复用中的应用
这篇文档主要讨论了TCP（传输控制协议）的状态转换以及如何使用select和poll两种方法进行IO多路复用。TCP是一种面向连接的、可靠的传输层协议，其连接过程涉及多个状态，这些状态在通信过程中起着关键作用。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值