C/S模型测试及优化

已于 2024-06-19 00:00:46 修改
阅读量272 收藏
点赞数 3
文章标签： tcp/ip
于 2024-05-31 22:18:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63713157/article/details/139360186
版权

1

1.1代码示例

#include<stdio.h>
#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

int main(void)
{
	int sockfd=0;
	int ret=0;
	struct sockaddr_in seraddr;

	char tmpbuff[4096]={"I need some offers"};
	int cnt=0;
	ssize_t nsize=0;

	/* 1 创建网络套接字 */
	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(-1==sockfd)
	{
		perror("fail to socket");
		return -1;
	}

	/* 2 初始化网络地址结构体 */
	seraddr.sin_family=AF_INET;
	seraddr.sin_port=htons(50000);
	seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

	/* 3 发送连接请求 */
	ret=connect(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
	if(-1==ret)
	{
		perror("fail to connect");
		return -1;
	}

	/* 4 客户端与服务器交互 */
	while(1)
	{
#if 0
		/* 4.1 清空发送缓冲区 */
		memset(tmpbuff,0,sizeof(tmpbuff));
		/* 4.2 拼接数据 */
		sprintf(tmpbuff,"client send:### %d",cnt);
		cnt++;

		/* 4.3 发送数据到网络套接字 */
		nsize=send(sockfd,tmpbuff,strlen(tmpbuff),0);
		if(-1==nsize)
		{
			perror("fail to send");
			return -1;
		}
#endif

#if 1
		/* 清空接收缓冲区 */
		memset(tmpbuff,0,sizeof(tmpbuff));
		/* 接收网络套接字数据 */
		nsize=recv(sockfd,tmpbuff,sizeof(tmpbuff),0);
		if(-1==nsize)
		{
			perror("fail to recv");
			return -1;
		}
#endif
		
		/* 显示接收数据 */
		printf("client recv:### %s\n",tmpbuff);
	}

	/* 5 关闭网络套接字 */
	close(sockfd);

	return 0;
}



int main(void)
{
    int sockfd=0;
    struct sockaddr_in seraddr;
    int ret=0; 

    int confd=0;
    char tmpbuff[4096]={0};
    ssize_t nsize=0;

    /* 1 创建网络套接字 */
    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(-1==sockfd)
    {
        perror("fail to socket");
        return -1;
    }
    
    /* 2 初始化网络地址结构体 */
    seraddr.sin_family=AF_INET;
    seraddr.sin_port=htons(50000);
    seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

    /* 3 绑定网络套接字 */
    ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
    if(-1==ret)
    {
        perror("fail to bind");
        return -1;
    }

    /* 4 监听网络套接字 */
    ret=listen(sockfd,10);
    if(-1==ret)
    {
        perror("fail to listen");
        return -1;
    }

    /* 5 服务器与客户端交互 */
    while(1)
    {
        /* 5.1 创建通信套接字-阻塞等待网络套接字连接请求*/
        confd=accept(sockfd,NULL,NULL);
        if(-1==confd)
        {
            perror("fail to accept");
            return -1;
        }

#if 0
        /* 5.2 清空接收缓冲区 */
        memset(tmpbuff,0,sizeof(tmpbuff));
        /* 5.3 接收通信套接字数据-并做接收完成处理 */
        nsize=recv(confd,tmpbuff,sizeof(tmpbuff),0);
        if(-1==nsize)
        {
            perror("fail to recv");
            return -1;
        }
        else if(0==nsize)
        {
            return 0;
        }
#endif
        
        /* 5.2 清空发送缓冲区 */
        memset(tmpbuff,0,sizeof(tmpbuff));
        /* 5.4 拼接 */
        sprintf(tmpbuff,"server send:### %s",tmpbuff);
        /* 5.5 发送 */
        nsize=send(confd,tmpbuff,strlen(tmpbuff),0);
        if(-1==nsize)
        {
            perror("fail to send");
            return -1;
        }
    }

    /* 6 关闭通信套接字 */
    close(confd);
    /* 7 关闭网络套接字 */
    close(sockfd);

    return 0;
}

1.2运行结果

（1）运行服务器
（2）运行客户端

现象如下：
	客户端发生阻塞

在这里插入图片描述

（1）关闭服务器：
	客户端不阻塞-说明recv函数为非阻塞状态

在这里插入图片描述

总结：
（1）如果将服务器accept函数放在while循环内部：同时运行客户端与服务器，可以发现服务器可以与多个客户端建立连接（解决的问题-服务器并发访问）。
（2）但是只能进行一次数据发送（虽然解决了服务器的并发访问问题，但是对于大量的数据传输却手足无措）
			小意外：当服务器端退出，此时客户端不再阻塞，正常执行函数体。（这就说明了，此时recv函数为非阻塞状态=》那么服务器和客户端同时运行，为什么会发生阻塞？）

补充：
（1）如果将服务器端accept函数放在while循环外部（对比TCP文件传输）：
	1）只有一个客户端能够与服务器建立连接并进行数据收发；其它客户端被阻塞，无法与服务器建立连接。（问题：（1）服务器只能与一个客户端建立连接？（2）那么如何解决这个问题？（3）是从服务端解决这个问题，还是从客户端解决这个问题？	先解决问题（3）：显然，要解决这个问题肯定是要从服务器端去解决--客户端是向服务器端发起连接请求，那么具体是否能够建立连接，显然是取决于服务器端的意愿和能力；所以，多个客户端向服务器端发起连接请求，能不能实现的关键在于服务器能不能接受多个客户端接入，服务器端是否允许多个客户端接入。	下面再解决问题（2）：解决这个问题，其实用一句话来表述就是解决服务器并发访问问题，这个问题后面专项解决，现在只需要明白所面临的问题是服务器并发访问的问题即可。）

（2）如果将connect函数放在循环外部，将accept函数放在循环外部，此时意味着：客户端与服务器端第一次建立连接，可以发送一次数据；发完数据接着进行第二次，第三次。。。连接请求；此时当然是报错！因为同一个网络套接字只能建立一次连接，不能重复建立连接（这是由TCP通信机制决定的）；但是这种方式可以将服务器同时与多个客户端建立连接。。。。。。。。。。。。。。总结一下就是：客户端与服务器端要进行多次请求连接-建立连接；那么每进行一次通信，都必须关闭（close）通信套接字（已经建立三次握手，四次挥手连接的套接字confd-accept）。

在这里插入图片描述

2 多线程解决TCP并发问题

2.1 源码示例

/*************************************************************************
	> File Name: client.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月01日 星期六 10时44分42秒
 ************************************************************************/

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

int main(void)
{
    int sockfd=0;
    
    struct sockaddr_in seraddr;

    int ret=0;

    ssize_t nsize=0;
    char sendbuffer[4096]={"|c-send|"};
    char recvbuffer[4096]={"|c-recv|"};
	int cnt=100;

    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(-1==sockfd)
    {
        perror("fail to socket");
        return -1;
    }

    seraddr.sin_family=AF_INET;
    seraddr.sin_port=htons(50000);//本地字节序转换为网络大端字节序
    seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");//字符串IP转为内存中的IP

    ret=connect(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
    if(-1==ret)
    {
        perror("fail to connect");
        return -1;
    }

    while(1)
    {	
        memset(sendbuffer,0,sizeof(sendbuffer));
        sprintf(sendbuffer,"< %d >",--cnt);
        nsize=send(sockfd,sendbuffer,sizeof(sendbuffer),0);
        if(-1==nsize)
        {
            perror("fail to send");
            return -1;
        }
		printf("client send: %s\n",sendbuffer);
		sleep(1);

        memset(recvbuffer,0,sizeof(recvbuffer));
        nsize=recv(sockfd,recvbuffer,sizeof(recvbuffer),0);
        if(-1==nsize)
        {
            perror("fail to recv");
            return -1;
        }
		printf("client recv: %s\n",recvbuffer);
		sleep(1);
    }

    return 0;
}

/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月01日 星期六 14时17分47秒
 ************************************************************************/

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

#include <pthread.h>


void *handle_tcp_client(void *arg);

int main(void)
{
    pthread_t tid=0;
    pthread_attr_t attr;

    int sockfd=0;

    struct sockaddr_in seraddr;

    int ret=0;
    
    int confd=0;

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(-1==sockfd)
    {
        perror("fail to sockfd");
        return -1;
    }

    seraddr.sin_family=AF_INET;
    seraddr.sin_port=htons(50000);
    seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

    ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));//警告: 结构体类型强制转换?
    if(-1==ret)
    {
        perror("fail to bind");
        return -1;
    }

    ret=listen(sockfd,10);
    if(-1==ret)
    {
        perror("fail to listen");
        return -1;
    }

    while(1)
    {
        confd=accept(sockfd,NULL,NULL);
        if(-1==confd)
        {
            perror("fail to accept");
            return -1;
        }
#if 0
        /* <1> 线程回调函数传参-粗心传参*/
        pthread_create(&tid,&attr,handle_tcp_client,&confd);
#endif
#if 1
        /* <1> 线程回调函数传参-细节优化*/
        pthread_create(&tid,&attr,handle_tcp_client,confd);//线程回调函数传参，传的是指针，这里直接传值?
#endif
    }

    close(sockfd);

    return 0;
}

void *handle_tcp_client(void *arg)
{
    ssize_t nsize=0;
    char sendbuffer[4096]={"|s-send|"};
    char recvbuffer[4096]={"|s-recv|"};
#if 0
    /* <1> 线程回调函数传参-粗心传参*/
    int confd=*(int *)arg;
#endif
#if 1
    /* <1> 线程回调函数传参-细节优化*/
    int confd=arg;
#endif
    int cnt=0;

    while(1)
    {
        memset(recvbuffer,0,sizeof(recvbuffer));
        nsize=recv(confd,recvbuffer,sizeof(recvbuffer),0);
        if(-1==nsize)
        {
            perror("fail to recv");
            return NULL;
        }
        else if(0==nsize)
        {
            return NULL;
        }
        printf("server recv: %s\n",recvbuffer);
		sleep(1);

        memset(sendbuffer,0,sizeof(sendbuffer));
        sprintf(sendbuffer,"< %d >",++cnt);
        nsize=send(confd,sendbuffer,strlen(sendbuffer),0);
        if(-1==nsize)
        {
            perror("fail to send");
            return NULL;
        }
        printf("server send: %s\n",sendbuffer);
		sleep(1);
    }

    return NULL;
}

2.2 运行结果

在这里插入图片描述

2.3 分析总结

服务器端：
	两次接收：两个客户端与服务器端建立连接，接受两个客户端分别发送过来的数据；
	两次发送：服务器端与两个客户端建立连接，发送数据时向两个客户端分别发送一次数据。
	
客户端：
	一次发送：向服务器端发送一次数据。
	一次接收：接受服务器端发送过来的数据。

问题：
	（1）如果连入多个客户端，那么就创建了多个通信套接字（confd）；服务器端创建多线程的时候，为回调函数传参问题：
		1）回调函数传参传【&confd】：那么后建立的服务器端与客户端的连接产生的文件描述符（confd）就会将先建立的服务器端与客户端的连接产生的文件描述符（confd）覆盖；这将会导致不同的客户端的不同数据请求得到服务器端的数据响应是一样的（即只有一个客户端可以收到自己想要的数据，而其它的客户端收到的将不是自己请求的数据）。
		2）回调函数传参传【confd】：就可以解决先建立连接产生的文件描述符被覆盖的问题。（同时编译过程中产生2个警告！）
	（2）运行效果：

在这里插入图片描述

3 IO多路复用解决TCP并发问题

3.1 select

select基本原理是：
	（1）监听所有文件描述符，将处于非ready态的文件描述符从监听集合中清除，只留下ready态的文件描述符在文件描述符集合中。（保留符合）
	（2）查询文件描述符集合中仍然存在的文件描述符，哪个文件描述符有事件发生，则从对应的文件描述符读数据。

3.1.1 源码示例

3.1.1 客户端
/*************************************************************************
	> File Name: client.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月03日 星期一 16时12分48秒
 ************************************************************************/

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

int main(void)
{
    int sockfd=0;

    struct sockaddr_in seraddr;

    int ret=0;

    ssize_t nsize=0;
    char sendbuffer[4096]={0};
    char recvbuffer[4096]={0};

    int send_cnt=1;
//    int recv_cnt=99;

    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(-1==sockfd)
    {
        perror("fail to socket");
        return -1;
    }

    seraddr.sin_family=AF_INET;
    seraddr.sin_port=htons(50000);
    seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

    ret=connect(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
    if(-1==ret)
    {
        perror("fail to connect");
        return -1;
    }

    while(1)
    {
        memset(sendbuffer,0,sizeof(sendbuffer));
        sprintf(sendbuffer,"|%-3d|",send_cnt++);
        nsize=send(sockfd,sendbuffer,sizeof(sendbuffer),0);
        if(-1==nsize)
        {
            perror("fail to send");
            return -1;
        }
        printf("client send: %s\n",sendbuffer);

        memset(recvbuffer,0,sizeof(recvbuffer));
        nsize=recv(sockfd,recvbuffer,sizeof(recvbuffer),0);
        if(-1==nsize)
        {
            perror("fail to recv");
            return -1;
        }
        printf("client recv: %s\n",recvbuffer);
        
		/* 方便查看运行结果*/
        sleep(3);
    }

    close(sockfd);

    return 0;
}
3.1.2 服务器端
/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月03日 星期一 17时01分50秒
 ************************************************************************/

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

int main(void)
{
	int sockfd=0;

	struct sockaddr_in seraddr;

	int ret=0;

	int confd=0;
	int maxfd=0;

	ssize_t nsize=0;
	char sendbuffer[4096]={0};
	char recvbuffer[4096]={0};
	
	int send_cnt=99;

	fd_set rdfds;
	fd_set tmpfds;

	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(-1==sockfd)
	{
		perror("fail to socket");
		return -1;
	}

	seraddr.sin_family=AF_INET;
	seraddr.sin_port=htons(50000);
	seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

	ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
	if(-1==ret)
	{
		perror("fail to bind");
		return -1;
	}

	ret=listen(sockfd,10);
	if(-1==ret)
	{
		perror("fail to listen");
		return -1;
	}

	/* 文件描述符集操作 */
	FD_ZERO(&rdfds);//初始化文件描述符集合
	FD_SET(sockfd,&rdfds);//添加文件描述符至文件描述符集合

	while(1)
	{
		/* 初始化监听文件描述符集合 */
		tmpfds=rdfds;
		/* 监听文件描述符集合 */
		ret=select(sockfd+1,&tmpfds,NULL,NULL,NULL);
		if(-1==ret)
		{
			perror("fail to select");
			return -1;
		}

		/* 查询文件描述符集合中文件描述符状态*/
		if(FD_ISSET(sockfd,&tmpfds))
		{
			confd=accept(sockfd,NULL,NULL);
			/* 注意: 异常处理(3个操作) */
			if(-1==confd)
			{
				perror("fail to accept");
				FD_CLR(sockfd,&rdfds);//将套接字文件描述符从文件描述符集合中删除
				close(sockfd);//关闭套接字文件
				continue;//既然建立TCP连接失败,跳过TCP收发过程也理所当然
			}

			FD_SET(confd,&rdfds);
//			maxfd = maxfd > confd ? maxfd : confd;
		}



		/* 查询文件描述符集合中文件描述符状态 */
		if(FD_ISSET(sockfd,&tmpfds))
		{

			memset(recvbuffer,0,sizeof(recvbuffer));
			nsize=recv(confd,recvbuffer,sizeof(recvbuffer),0);
			if(-1==nsize)
			{
				perror("fail to recv");
				return -1;
			}
			printf("server recv: %s\n",recvbuffer);

			memset(sendbuffer,0,sizeof(sendbuffer));
			sprintf(sendbuffer,"|%-3d|",send_cnt--);
			nsize=send(confd,sendbuffer,sizeof(sendbuffer),0);
			if(-1==nsize)
			{
				perror("fail to send");
				return -1;
			}
			printf("server send: %s\n",sendbuffer);
		}

		/* 方便查看运行结果*/
		sleep(3);
	}
	
	
	close(confd);
	close(sockfd);
}

运行结果：
在这里插入图片描述

3.1.3 服务器端改进 1
通过maxfd获取最大文件描述符

/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月03日 星期一 17时01分50秒
 ************************************************************************/

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

int main(void)
{
	int sockfd=0;

	struct sockaddr_in seraddr;

	int ret=0;

	int confd=0;
	int maxfd=0;

	ssize_t nsize=0;
	char sendbuffer[4096]={0};
	char recvbuffer[4096]={0};
	
	int send_cnt=99;

	fd_set rdfds;
	fd_set tmpfds;

	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(-1==sockfd)
	{
		perror("fail to socket");
		return -1;
	}

	seraddr.sin_family=AF_INET;
	seraddr.sin_port=htons(50000);
	seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

	ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
	if(-1==ret)
	{
		perror("fail to bind");
		return -1;
	}

	ret=listen(sockfd,10);
	if(-1==ret)
	{
		perror("fail to listen");
		return -1;
	}

	/* 文件描述符集操作 */
	FD_ZERO(&rdfds);//初始化文件描述符集合
	FD_SET(sockfd,&rdfds);//添加文件描述符至文件描述符集合
    maxfd=sockfd;

	while(1)
	{
		/* 初始化监听文件描述符集合 */
		tmpfds=rdfds;
		/* 监听文件描述符集合 */
		ret=select(maxfd+1,&tmpfds,NULL,NULL,NULL);
		if(-1==ret)
		{
			perror("fail to select");
			return -1;
		}

		/* 查询文件描述符集合中文件描述符状态*/
		if(FD_ISSET(sockfd,&tmpfds))
		{
			confd=accept(sockfd,NULL,NULL);
			/* 注意: 异常处理(3个操作) */
			if(-1==confd)
			{
				perror("fail to accept");
				FD_CLR(sockfd,&rdfds);//将套接字文件描述符从文件描述符集合中删除
				close(sockfd);//关闭套接字文件
				continue;//既然建立TCP连接失败,跳过TCP收发过程也理所当然
			}

			FD_SET(confd,&rdfds);
			maxfd = maxfd > confd ? maxfd : confd;
		}



		/* 查询文件描述符集合中文件描述符状态 */
		if(FD_ISSET(sockfd,&tmpfds))
		{

			memset(recvbuffer,0,sizeof(recvbuffer));
			nsize=recv(confd,recvbuffer,sizeof(recvbuffer),0);
			if(-1==nsize)
			{
				perror("fail to recv");
				return -1;
			}
			printf("server recv: %s\n",recvbuffer);

			memset(sendbuffer,0,sizeof(sendbuffer));
			sprintf(sendbuffer,"|%-3d|",send_cnt--);
			nsize=send(confd,sendbuffer,sizeof(sendbuffer),0);
			if(-1==nsize)
			{
				perror("fail to send");
				return -1;
			}
			printf("server send: %s\n",sendbuffer);
		}

		/* 方便查看运行结果*/
		sleep(3);
	}

	close(confd);
	close(sockfd);

	return 0;
}

运行结果：
在这里插入图片描述
（1）只有一次数据通信
（2）关闭服务器端：客户端自动断开

3.1.4 服务器端改进 2
/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月03日 星期一 17时01分50秒
 ************************************************************************/

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

int main(void)
{
	int sockfd=0;

	struct sockaddr_in seraddr;

	int ret=0;

	int confd=0;
	int maxfd=0;

	ssize_t nsize=0;
	char sendbuffer[4096]={0};
	char recvbuffer[4096]={0};
	
	int send_cnt=99;

	fd_set rdfds;
	fd_set tmpfds;

    int i=0;

	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(-1==sockfd)
	{
		perror("fail to socket");
		return -1;
	}

	seraddr.sin_family=AF_INET;
	seraddr.sin_port=htons(50000);
	seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

	ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
	if(-1==ret)
	{
		perror("fail to bind");
		return -1;
	}

	ret=listen(sockfd,10);
	if(-1==ret)
	{
		perror("fail to listen");
		return -1;
	}

	/* 1 文件描述符集操作 */
	FD_ZERO(&rdfds);//初始化文件描述符集合
	FD_SET(sockfd,&rdfds);//添加文件描述符至文件描述符集合
    maxfd=sockfd;

	while(1)
	{
		/* 2 初始化监听文件描述符集合 */
		tmpfds=rdfds;
		/* 3 监听文件描述符集合 */
		ret=select(maxfd+1,&tmpfds,NULL,NULL,NULL);
		if(-1==ret)
		{
			perror("fail to select");
			return -1;
		}

		/* 4 查询文件描述符集合中sockfd文件描述符状态*/
		if(FD_ISSET(sockfd,&tmpfds))
		{
            /* 建立通信文件描述符 - 监听是否有新的文件描述符加入 */
			confd=accept(sockfd,NULL,NULL);
			/* 注意: 异常处理(3个操作) */
			if(-1==confd)
			{
				perror("fail to accept");
				FD_CLR(sockfd,&rdfds);//将套接字文件描述符从文件描述符集合中删除
				close(sockfd);//关闭套接字文件
				continue;//既然建立TCP连接失败,跳过TCP收发过程也理所当然
			}

			FD_SET(confd,&rdfds);
			maxfd = maxfd > confd ? maxfd : confd;
        }


        for(i=sockfd+1;i<=maxfd;i++)//sockfd是第1个被监听的文件描述符,也是3个标准流除外的最小文件描述符
        {
            /* 查询文件描述符集合中文件描述符状态,并进行IO操作 */
            if(FD_ISSET(i,&tmpfds))
            {
                /* IO操作 */
                memset(recvbuffer,0,sizeof(recvbuffer));
                nsize=recv(i,recvbuffer,sizeof(recvbuffer),0);//每个被监听的文件描述符i
                if(-1==nsize)
                {
                    perror("fail to recv");
                }
                printf("server recv: %s\n",recvbuffer);

                memset(sendbuffer,0,sizeof(sendbuffer));
                sprintf(sendbuffer,"|%-3d|",send_cnt--);
                nsize=send(i,sendbuffer,sizeof(sendbuffer),0);//每个被监听的文件描述符i
                if(-1==nsize)
                {
                    perror("fail to send");
                }
                printf("server send: %s\n",sendbuffer);

                /* IO操作异常处理*/
                if(-1==nsize)
                {
                    fprintf(stderr,"server disconnected!\n");//服务器端异常报错
                    FD_CLR(i,&rdfds);
                    close(i);
                    continue;
                }
                else if(0==nsize)
                {
                    fprintf(stderr,"client disconnected!\n");//客户端异常报错
                    FD_CLR(i,&rdfds);
                    close(i);
                    continue;
                }
            }
        }

        /* 方便查看运行结果*/
        sleep(3);
    }

    close(confd);
	close(sockfd);

	return 0;
}

3.1.5 运行结果

在这里插入图片描述
完成TCP并发。

3.1.6 分析总结

（1）

（2）关于select：
		1）select监听文件描述符上限：【1024】。
		2）select需要将数据从内核层向用户层空间拷贝；占用系统资源开销。
		3）select只能工作在水平触发模式（低速模式），无法工作在边沿触发（高速模式）。

3.2 poll

3.2.1 源码示例

（1）原始代码

/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月04日 星期二 21时23分30秒
 ************************************************************************/

#include<stdio.h>

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

#include <poll.h>

int main(void)
{
	int sockfd=0;

	struct sockaddr_in seraddr;

	int ret=0;

	int confd=0;

	ssize_t nsize=0;
	char sendbuffer[4096]={0};
	char recvbuffer[4096]={0};

	int send_cnt=99;

	struct pollfd fds[1024];
    int nready=0;
	int i=0;
    int j=0;

	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(-1==sockfd)
	{
		perror("fail to socket");
		return -1;
	}

	seraddr.sin_family=AF_INET;
	seraddr.sin_port=htons(50000);
	seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

	ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
	if(-1==ret)
	{
		perror("fail to bind");
		return -1;
	}

	ret=listen(sockfd,10);
	if(-1==ret)
	{
		perror("fail to listen");
		return -1;
	}

	/* 1.1 初始化文件描述符状态结构体数组 */
	for(i=0;i<1024;++i)
	{
		fds[i].fd=-1;//未使用的文件描述符状态结构体数组元素初始化为-1(作为标志-未使用)
	}
	/* 1.2 初始化文件描述符状态结构体数组 */
	for(i=0;i<1024;++i)
	{
		/* 将文件描述符添加到数组空位置中 */
		if(fds[i].fd==-1)
		{
			fds[i].fd=sockfd;//未使用的文件描述符状态结构体数组元素初始化为-1(作为标志-未使用)
			fds[i].events=POLLIN;

			break;
		}
	}

	while(1)
	{
		/* 2 监听文件描述符状态结构体数组 */
		nready=poll(fds,1024,-1);//数组 - 长度 - 一直等
		if(-1==nready)
		{
			perror("fail to poll");
			return -1;
		}

        /* 3 查询文件描述符状态 - 查询方式: 位掩码 - 置位 */
        for(i=0;i<1024;++i)
        {
            if(fds[i].fd==-1)
            {
                continue;
            }

            if((fds[i].revents & POLLIN) && (fds[i].fd==sockfd))
            {
                confd=accept(sockfd,NULL,NULL);
                if(-1==confd)
                {
                    perror("fail to accept");
                    for(j=0;j<1024;++j)
                    {
                        if(fds[j].fd=sockfd)
                        {
                            fds[j].fd=-1;

                            break;
                        }
                    }
                    close(sockfd);

                    continue;
                }

                /* 将confd添加进来 */
                for(i=0;i<1024;++i)
                {
                    /* 将文件描述符添加到数组空位置中 */
                    if(fds[i].fd==-1)
                    {
                        fds[i].fd=confd;//未使用的文件描述符状态结构体数组元素初始化为-1(作为标志-未使用)
                        fds[i].events=POLLIN;

                        break;
                    }
                }
            }
            else if((fds[i].revents & POLLIN) &&(fds[i].fd!=sockfd))
            {
                memset(recvbuffer,0,sizeof(recvbuffer));
                nsize=recv(fds[i].fd,recvbuffer,sizeof(recvbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to recv");
                }
                printf("server recv: %s\n",recvbuffer);

                memset(sendbuffer,0,sizeof(recvbuffer));
                sprintf(sendbuffer,"|%-3d|",send_cnt--);
                nsize=send(fds[i].fd,sendbuffer,strlen(sendbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to send");
                }
                printf("server send: %s\n",sendbuffer);

                /* IO异常处理 */
                if(-1==nsize)
                {
                    fprintf(stderr,"server disconnected!\n");//服务器端异常报错
                    close(fds[i].fd);
                    /* 从fds集合中删除fd */
                    for(j=0;j<1024;++j)
                    {
                        if(fds[j].fd=fds[i].fd)
                        {
                            fds[j].fd=-1;

                            break;
                        }
                    }
                    continue;
                }
                else if(0==nsize)
                {
                    fprintf(stderr,"client disconnected!\n");//客户端异常报错
                    close(fds[i].fd);
                    /* 从fds集合中删除fd */
                    for(j=0;j<1024;++j)
                    {
                        if(fds[j].fd=fds[i].fd)
                        {
                            fds[j].fd=-1;

                            break;
                        }
                    }
                    continue;
                }
            }
        }

        sleep(3);//方便分析运行结果
    }

    close(sockfd);

    return 0;
}

（2）函数封装

/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月04日 星期二 21时23分30秒
 ************************************************************************/

#include<stdio.h>

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

#include <poll.h>

int fds_init(struct pollfd *fds,int maxlen);
int fd_add(struct pollfd *fds,int maxlen,int fd,short env);
int fd_delete(struct pollfd *fds,int maxlen,int fd);

int main(void)
{
	int sockfd=0;

	struct sockaddr_in seraddr;

	int ret=0;

	int confd=0;

	ssize_t nsize=0;
	char sendbuffer[4096]={0};
	char recvbuffer[4096]={0};

	int send_cnt=99;

	struct pollfd fds[1024];
    int nready=0;
	int i=0;
    int j=0;

	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(-1==sockfd)
	{
		perror("fail to socket");
		return -1;
	}

	seraddr.sin_family=AF_INET;
	seraddr.sin_port=htons(50000);
	seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

	ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
	if(-1==ret)
	{
		perror("fail to bind");
		return -1;
	}

	ret=listen(sockfd,10);
	if(-1==ret)
	{
		perror("fail to listen");
		return -1;
	}

    fds_init(fds,1024);
    fd_add(fds,1024,sockfd,POLLIN);

	while(1)
	{
		/* 2 监听文件描述符状态结构体数组 */
		nready=poll(fds,1024,-1);//数组 - 长度 - 一直等
		if(-1==nready)
		{
			perror("fail to poll");
			return -1;
		}

        /* 3 查询文件描述符状态 - 查询方式: 位掩码 - 置位 */
        for(i=0;i<1024;++i)
        {
            if(fds[i].fd==-1)
            {
                continue;
            }

            if((fds[i].revents & POLLIN) && (fds[i].fd==sockfd))
            {
                confd=accept(sockfd,NULL,NULL);
                if(-1==confd)
                {
                    perror("fail to accept");
                    fd_delete(fds,1024,sockfd);
                    close(sockfd);

                    continue;
                }
                fd_add(fds,1024,confd,POLLIN);
            }
            else if((fds[i].revents & POLLIN) &&(fds[i].fd!=sockfd))
            {
                memset(recvbuffer,0,sizeof(recvbuffer));
                nsize=recv(fds[i].fd,recvbuffer,sizeof(recvbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to recv");
                }
                printf("server recv: %s\n",recvbuffer);

                memset(sendbuffer,0,sizeof(recvbuffer));
                sprintf(sendbuffer,"|%-3d|",send_cnt--);
                nsize=send(fds[i].fd,sendbuffer,strlen(sendbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to send");
                }
                printf("server send: %s\n",sendbuffer);

                /* IO异常处理 */
                if(-1==nsize)
                {
                    fprintf(stderr,"server disconnected!\n");//服务器端异常报错
                    close(fds[i].fd);
                    fd_delete(fds,1024,fds[i].fd);

                    continue;
                }
                else if(0==nsize)
                {
                    fprintf(stderr,"client disconnected!\n");//客户端异常报错
                    close(fds[i].fd);
                    fd_delete(fds,1024,fds[i].fd);

                    continue;
                }
            }
        }

        sleep(3);//方便分析运行结果
    }

    close(sockfd);

    return 0;
}

int fds_init(struct pollfd *fds,int maxlen)
{
    int i=0;

    for(i=0;i<maxlen;++i)
    {
        fds[i].fd=-1;
    }

    return 0;
}

int fd_add(struct pollfd *fds,int maxlen,int fd,short env)
{
    int i=0;

    for(i=0;i<maxlen;++i)
    {
        if(fds[i].fd==-1)
        {
            fds[i].fd=fd;
            fds[i].events=env;

            break;
        }
    }

    if(i==maxlen)
    {
        return -1;
    }

    return 0;
}

int fd_delete(struct pollfd *fds,int maxlen,int fd)
{
    int i=0;

    for(i=0;i<maxlen;++i)
    {
        if(fds[i].fd==fd)
        {
            fds[i].fd=-1;

            break;
        }
    }
}

3.2.2 运行结果

在这里插入图片描述

3.2.3 分析总结

1.【poll】由内核层向用户层数据空间拷贝的过程中，占用系统资源开销
2.【poll】必须轮询检测生产事件的文件描述符
3.【poll】只能工作在水平触发模式（低速模式），无法工作在边沿触发（高速模式）

3.3 epoll

3.3.1 源码示例

（1）客户端：

/*************************************************************************
	> File Name: client.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月13日 星期四 07时39分26秒
 ************************************************************************/
#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

int main(void)
{
    int sockfd=0;

    struct sockaddr_in seraddr;

    int ret=0;

    ssize_t nsize=0;
    char sendbuffer[4096]={0};
    char recvbuffer[4096]={0};
    int send_cnt=1;

    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(-1==sockfd)
    {
        perror("fail to socket");
        return -1;
    }

    seraddr.sin_family=AF_INET;
    seraddr.sin_port=htons(50000);
    seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

    ret=connect(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
    if(-1==ret)
    {
        perror("fail to connect");
        return -1;
    }

    while(1)
    {
        memset(sendbuffer,0,sizeof(sendbuffer));
        sprintf(sendbuffer,"|%-3d|",send_cnt++);
        nsize=send(sockfd,sendbuffer,strlen(sendbuffer),0);
        if(-1==nsize)
        {
            perror("fail to send");
            return -1;
        }
		printf("client send: %s\n",sendbuffer);

        memset(recvbuffer,0,sizeof(recvbuffer));
        nsize=recv(sockfd,recvbuffer,sizeof(recvbuffer),0);
        if(-1==nsize)
        {
            perror("fail to recv");
            return -1;
        }
		printf("client recv: %s\n",recvbuffer);
        
		sleep(3);//便于分析运行结果
    }

    close(sockfd);

    return 0;
}

（2）服务器原始代码：

/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月13日 星期四 08时07分01秒
 ************************************************************************/
#include<stdio.h>

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

#include <sys/epoll.h>

int main(void)
{
    int sockfd=0;

    struct sockaddr_in seraddr;

    int ret=0;

    int confd=0;

    ssize_t nsize=0;
    char sendbuffer[4096]={0};
    char recvbuffer[4096]={0};
    int send_cnt=99;

    int epfd=0;

    int nready=0;

    int i=0;

    struct epoll_event retenv[1024];
    struct epoll_event tmpenv;

    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(-1==sockfd)
    {
        perror("fail to sockfd");
        return -1;
    }

    seraddr.sin_family=AF_INET;
    seraddr.sin_port=htons(50000);
    seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

    ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
    if(-1==ret)
    {
        perror("fail to bind");
        return -1;
    }

    ret=listen(sockfd,10);
    if(-1==ret)
    {
        perror("fail to ret");
        return -1;
    }

    /* 1 创建内核事件表 - 并返回表头 */
    epfd=epoll_create(1024);
    if(-1==epfd)
    {
        perror("fail to epoll_create");
        return -1;
    }

    /* 2 初始化内核epoll事件结构体 */
    tmpenv.events=EPOLLIN;
    tmpenv.data.fd=sockfd;
    ret=epoll_ctl(epfd,EPOLL_CTL_ADD,sockfd,&tmpenv);
    if(-1==ret)
    {
        perror("fail to epoll_ctl");
        return -1;
    }   

    while(1)
    {
        /* 监听文件描述符状态结构体数组 */
        nready=epoll_wait(epfd,retenv,1024,-1);
        if(-1==nready)
        {
            perror("fail to epoll_wait");
            return -1;
        }

        for(i=0;i<nready;i++)
        {
            if(retenv[i].data.fd==sockfd)
            {
                confd=accept(sockfd,NULL,NULL);
                if(-1==confd)
                {
                    perror("fail to accept");
                    ret=epoll_ctl(epfd,EPOLL_CTL_DEL,sockfd,NULL);
                    if(-1==ret)
                    {
                        perror("fail to epoll_ctl");
                        return -1;
                    }
                    close(sockfd);

                    continue;
                }

                /**/
                #if 0
                fd_add();
                #endif
                tmpenv.events=EPOLLIN;
                tmpenv.data.fd=confd;
                ret=epoll_ctl(epfd,EPOLL_CTL_ADD,confd,&tmpenv);
                if(-1==ret)
                {
                    perror("fail to epoll_ctl");
                    return -1;
                }
            }
            else if(retenv[i].data.fd!=sockfd)
            {
                memset(recvbuffer,0,sizeof(recvbuffer));
                nsize=recv(retenv[i].data.fd,recvbuffer,sizeof(recvbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to recv");
                    return -1;
                }
                printf("server recv: %s\n",recvbuffer);

                memset(sendbuffer,0,sizeof(sendbuffer));
                sprintf(sendbuffer,"|%-3d|",send_cnt--);
                nsize=send(retenv[i].data.fd,sendbuffer,strlen(sendbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to send");
                    return -1;
                }
                printf("server send: %s\n",sendbuffer);


                /* IO异常处理 */
                if(-1==nsize)
                {
                    fprintf(stderr,"server disconnected!\n");//服务器端异常报错
                    ret=epoll_ctl(epfd,EPOLL_CTL_DEL,retenv[i].data.fd,NULL);
                    if(-1==ret)
                    {
                        perror("fail to epoll_ctl");
                        return -1;
                    }
                    close(retenv[i].data.fd);

                    continue;
                }
                else if(0==nsize)
                {
                    fprintf(stderr,"client disconnected!\n");
                    ret=epoll_ctl(epfd,EPOLL_CTL_DEL,retenv[i].data.fd,NULL);
                    if(-1==ret)
                    {
                        perror("fail to epoll_ctl");
                        return -1;
                    }
                    close(retenv[i].data.fd);

                    continue;
                }
            }
        }

        sleep(3);//便于分析运行结果
    }

    close(epfd);
    close(sockfd);

    return 0;
}

（3）服务器函数封装优化：

/*************************************************************************
	> File Name: server.c
	> Author: yas
	> Mail: rage_yas@hotmail.com
	> Created Time: 2024年06月13日 星期四 08时07分01秒
 ************************************************************************/
#include<stdio.h>

#include<stdio.h>

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>

#include <sys/stat.h>
#include <fcntl.h>
    
#include <unistd.h>

#include <string.h>

#include <sys/epoll.h>

int fd_add(int epfd,int fd,uint32_t env);
int fd_delete(int epfd,int fd);

int main(void)
{
    int sockfd=0;

    struct sockaddr_in seraddr;

    int ret=0;

    int confd=0;

    ssize_t nsize=0;
    char sendbuffer[4096]={0};
    char recvbuffer[4096]={0};
    int send_cnt=99;

    int epfd=0;

    int nready=0;

    int i=0;

    struct epoll_event retenv[1024];
    struct epoll_event tmpenv;

    sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(-1==sockfd)
    {
        perror("fail to sockfd");
        return -1;
    }

    seraddr.sin_family=AF_INET;
    seraddr.sin_port=htons(50000);
    seraddr.sin_addr.s_addr=inet_addr("192.168.1.123");

    ret=bind(sockfd,(struct sockaddr *)&seraddr,sizeof(seraddr));
    if(-1==ret)
    {
        perror("fail to bind");
        return -1;
    }

    ret=listen(sockfd,10);
    if(-1==ret)
    {
        perror("fail to ret");
        return -1;
    }

    /* 1 创建内核事件表 - 并返回表头 */
    epfd=epoll_create(1024);
    if(-1==epfd)
    {
        perror("fail to epoll_create");
        return -1;
    }

    /* 2 初始化内核epoll事件结构体 */
    fd_add(epfd,sockfd,EPOLLIN);

    while(1)
    {
        /* 3 监听文件描述符状态结构体数组 */
        nready=epoll_wait(epfd,retenv,1024,-1);
        if(-1==nready)
        {
            perror("fail to epoll_wait");
            return -1;
        }

        /* 4 轮询处理 */
        for(i=0;i<nready;i++)
        {
            /* 如果sockfd套接字有事件发生, 则建立新的连接(有新的客户端加入) */
            if(retenv[i].data.fd==sockfd)
            {
                confd=accept(sockfd,NULL,NULL);
                /* 连接失败: 将sockfd套接字从事件表中删除 */
                if(-1==confd)
                {
                    perror("fail to accept");
                    fd_delete(epfd,sockfd);
                    close(sockfd);

                    continue;
                }

                /* 连接成功: 将confd通信套接字加入事件表 */
                fd_add(epfd,confd,EPOLLIN);
            }
            /* 如果不是sockfd套接字有事件发生, 则为正在进行通信(数据收发) */
            else if(retenv[i].data.fd!=sockfd)
            {
                memset(recvbuffer,0,sizeof(recvbuffer));
                nsize=recv(retenv[i].data.fd,recvbuffer,sizeof(recvbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to recv");
                    return -1;
                }
                printf("server recv: %s\n",recvbuffer);

                memset(sendbuffer,0,sizeof(sendbuffer));
                sprintf(sendbuffer,"|%-3d|",send_cnt--);
                nsize=send(retenv[i].data.fd,sendbuffer,strlen(sendbuffer),0);
                if(-1==nsize)
                {
                    perror("fail to send");
                    return -1;
                }
                printf("server send: %s\n",sendbuffer);


                /* IO异常处理 */
                if(-1==nsize)
                {
                    fprintf(stderr,"server disconnected!\n");//服务器端异常报错
                    fd_delete(epfd,retenv[i].data.fd);
                    close(retenv[i].data.fd);

                    continue;
                }
                else if(0==nsize)
                {
                    fprintf(stderr,"client disconnected!\n");
                    fd_delete(epfd,retenv[i].data.fd);
                    close(retenv[i].data.fd);

                    continue;
                }
            }
        }

        sleep(3);//便于分析运行结果
    }

    close(epfd);
    close(sockfd);

    return 0;
}

int fd_add(int epfd,int fd,uint32_t env)
{
    struct epoll_event tmpenv;
    int ret=0;

    tmpenv.events=env;
    tmpenv.data.fd=fd;
    ret=epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&tmpenv);
    if(-1==ret)
    {
        perror("fail to epoll_ctl");
        return -1;
    }

    return 0;
}

int fd_delete(int epfd,int fd)
{
    int ret=0;

    ret=epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);
    if(-1==ret)
    {
        perror("fail to epoll_ctl");
        return -1;
    }

    return 0;
}

3.3.2 运行结果

在这里插入图片描述

3.3.3 分析总结

1.【epoll】没有文件描述符上限限制
2.【epoll】创建内核监听事件表，所以只需要在内核空间完成数据拷贝即可
3.【epoll】会将产生事件的文件描述符对应的事件直接返回
4.【epoll】可以工作在水平触发模式（默认：低速模式），还可以工作在边沿触发模式（高速模式）
Filter~
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C 语言网络编程 — Socket I/O 性能优化手段
烟云的计算
05-04 4705
目录 文章目录目录基本概念同步与异步阻塞与非阻塞五种 IO 模型阻塞 IO非阻塞 IO同步 IO（信号驱动）异步 IOIO 多路复用selectpollepoll 基本概念 同步与异步 同步是指一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成。 异步是指不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了...
性能测试架构篇—C/S架构的应用性能测试模型分析
测试界的彭于晏的博客
09-08 2915
1. CS/CSS系统架构的基本概念 1.1系统架构定义 虽然B/S结构、J2EE架构愈来愈成为流行模式，但基于传统的C/S结构的应用程序还广泛地应用于各种行业。尤其是金融行业中的商业银行柜面－核心帐务 系统等。一方面由于传统商业银行一般都有大量的字符终端等需要复用的设备，一方面也是因为他们存在大量密集的对实时性要求很高的高柜业务，使用传统的基于 C/S结构或者C/S/S结构的应用效率更有保证。 C/S结构即CLIENT/SERVER结构。传统的C/S结构一般分为两层：客户端和服务器端。该结构的基本工作原理
模型优化
温染的笔记
05-31 3550
优化是应用数学的一个分支，也是机器学习的核心组成部分。实际上，机器学习算法 = 模型表征 + 模型评估 + 模型优化。其中，模型优化所做的事情就是在模型表征空间（假设空间）中找到模型评估指标最好的模型。需要注意的是不同的优化算法对应的模型表征和评估指标不尽相同。 先前，我很纠结是把损失函数放在模型评估中，还是放在模型优化这一篇博客中。准确地说，损失函数是用来作为模型评估的标准，不同的模型有不同的损...
谈谈机器学习AI模型测试与评估方法分析
肖永威的专栏
03-22 1万+
随着数字化转型与人工智能发展，AI应用软件层出不穷，人们虽然理解人工智能趋势，但是，企业往往很难接受这样AI应用软件，很很多质疑点，本文将从机器学习模型开发过程、AI应用软件开发过程，分析如何进行机器学习AI模型测试与模型评估方法。
DS/ML：数据科学技术之机器学习领域六大阶段最强学习路线(初步探索性数据分析EDA→数据预处理/广义的特征工程→模型训练/评估/推理→模型分析/反思/再优化→模型部署与监控→模型全流程优化)详解
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
12-31 6万+
DS/ML：数据科学技术之机器学习领域六大阶段最强学习路线(初步探索性数据分析EDA→数据预处理/广义的特征工程→模型训练/评估/推理→模型分析/反思/再优化→模型部署与监控→模型全流程优化)详解 导读：数据科学和机器学习实战最强学习路线，博主这次花了真的是好久好久的时间(大概数不清的凌晨吧)，以数据科学生命周期和机器学习工程化的视角进行了精心整理，今天终于结束了，真心不容易……希望能够对家学习数据科学和机器学习技术有所帮助。本文章是博主在数据科学和机器学习领域，先后实战过几百个应用案例之后的精心总结
模型评价与优化
qq_41602341的博客
11-01 1704
1.过拟合与欠拟合 欠拟合与过拟合： 训练数据 预测数据 欠拟合 不准确 不准确 过拟合 准确 不准确 好模型 准确 准确 欠拟合可以通过观察训练数据及时发现，通过优化模型结果解决。 如何解决过拟合问题： 原因：模型结构过于复杂（维度过高）；使用了过多属性，模型训练时包含了干扰项信息。 解决办法：简化数据模型（使用低阶模型，如线性模型）；数据PCA处理；模型训练时，增加正则...
常用自动化测试工具介绍（支持B/S、C/S）
onlyForCloud的专栏
07-19 4110
http://www.cnblogs.com/binbinxiong/p/3199836.html 一、功能测试工具 1、QTP测试工具 全名HP QuickTest Professional software ，最新的版本为HP QuickTest Professional 11.0 QTP是quicktest Professional的简称，是一种自动测试工具。使用QTP的目的
网络性能优化与测试
欧阳今朝的博客
01-07 1623
常见网络性能分析与优化
LLMs之Baichuan：Baichuan-7B/13B模型的简介、安装、使用方法之详细攻略
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
07-13 8442
​ LLMs之Baichuan：Baichuan-7B/13B模型的简介、安装、使用方法之详细攻略 目录 Baichuan-13B模型的简介 Baichuan-13B模型的安装 Baichuan-13B模型的使用方法 Baichuan-13B模型的简介 Baichuan-13B 是由百川智能继Baichuan-7B之后开发的包含 130 亿参数的开源可商用的大规模语言模型，在权威的中文和英文 benchmark 上均取得同尺寸最
软件测试必问必背面试题
热门推荐
weixin_45912307的博客
10-30 19万+
软件测试必问必背面试题 01 软件测试理论部分 1.1 测试概念 1. 请你分别介绍一下单元测试、集成测试、系统测试、验收测试、回归测试 单元测试：完成最小的软件设计单元（模块）的验证工作，目标是确保模块被正确的编码 集成测试：通过测试发现与模块接口有关的问题 系统测试：是基于系统整体需求说明书的黑盒类测试，应覆盖系统所有联合的部件 回归测试：回归测试是指在发生修改之后重新测试先前的测试用例以保证修改的正确性 验收测试：这时相关的用户或独立测试人员根据测试计划和结果对系统进行测试和接收。验收测试包括Al
java基于c/s的图书管理系统
05-04
在信息技术领域，C/S（Client/Server）架构是一种常见的应用模型，尤其在企业级应用中广泛使用。本系统——“java基于C/S的图书管理系统”，就是一个典型的应用实例，它实现了图书馆日常管理的核心功能，如借书、还...
简单C/S通信进程线程实现
01-21
在IT领域，尤其是在操作系统设计和网络编程中，C/S（客户端/服务器）架构是一种常见的通信模型，用于构建分布式系统。本课题"简单C/S通信进程线程实现"旨在探讨如何在C/S架构下通过进程和线程进行通信，并比较两者的...
基于C/S模式的TCP套接字的局域网收发消息程序
11-23
本项目“基于C/S模式的TCP套接字的局域网收发消息程序”正是这样一个利用C/S模型实现的局域网内消息传递系统。它通过TCP（Transmission Control Protocol）套接字进行数据交换，确保了数据的可靠传输。 首先，让...
java c/s sql srever oracle转换
11-20
Java C/S架构与SQL Server到Oracle的转换是一个复杂的过程，涉及到多个技术层面的调整和迁移。这个主题主要关注如何将基于Java的客户端/服务器（C/S）应用与使用SQL Server数据库系统转换为使用Oracle数据库系统。...
基于c/s的Java聊天软件
04-28
Java聊天软件是一种采用客户端/服务器（C/S）架构设计的通讯应用，它允许用户通过客户端程序与服务器进行实时交互。在本文中，我们将深入探讨基于C/S架构的Java聊天软件的开发知识，包括系统设计、网络通信、数据...
【LinuxC语言】TCPIP的经典5层结构
m0_62599305的博客
06-24 318
TCP/IP，全称传输控制协议/因特网互联协议，是用于在互联网上进行数据交换的一组协议，形成了互联网的基础。TCP/IP的经典五层结构包括：物理层、数据链路层、网络层、传输层和应用层。这些层次各自执行特定的网络功能，协同工作，使得复杂的网络通信成为可能。TCP/IP的五层模型为我们提供了一个理解和实现网络通信的框架。每一层都有其特定的职责和功能，确保数据能够从源点到达目的地。理解这个模型对于学习网络编程和解决网络问题是非常重要的。
【Linux 工具 】 tcpdump详细使用说明
最新发布
jingling122的博客
06-27 484
tcpdump 是一个在 Unix-like 系统上广泛使用的网络分析工具，用于捕获和分析网络数据包。以下是 tcpdump 的基本使用方法和一些常用选项的详细说明：1. 安装 tcpdump在大多数 Linux 发行版上，可以使用包管理器来安装 tcpdump。2. 使用 tcpdump 命令。
从移动切换到电信IP：详细介绍两种方法
hgdlip的博客
06-24 562
在当前的互联网环境中，用户可能会因为各种原因需要切换网络服务提供商，比如从移动切换到电信。这种切换不仅涉及到网络服务的变更，还可能意味着IP地址的改变。那么，移动的怎么切换成电信的IP？下面一起来了解一下吧。
宿主机无法通过ip连接wsl2解决方案
c2861024198的博客
06-26 458
解决宿主机无法通过ip链接wsl2 ubuntu的问题
使用onnx模型测试图片的代码
05-28
以下是使用ONNX模型测试图片的Python代码示例： ```python import onnxruntime as ort import numpy as np from PIL import Image # 加载ONNX模型 model_path = "your_model.onnx" session = ort.InferenceSession(model_path) # 输入图片的预处理 def preprocess(image_path): image = Image.open(image_path) image = image.resize((224, 224)) # 调整图片尺寸 image = np.array(image).astype(np.float32) image = image.transpose((2, 0, 1)) # 转置为 (C, H, W) 格式 image = image / 255.0 # 归一化 image = np.expand_dims(image, axis=0) # 增加 batch 维度 return image # 加载测试图片 image_path = "test.jpg" # 对测试图片进行预处理 image = preprocess(image_path) # 前向推理 output = session.run(None, {"input": image}) # 输出预测结果 print(output) ``` 在这个示例中，我们首先加载了ONNX模型文件，然后定义了一个预处理函数来对输入图片进行预处理。预处理函数将图片调整到模型期望的尺寸，并执行了归一化和维度转换操作。接下来，我们加载了测试图片，并对其进行预处理。最后，我们通过在 `session.run()` 中传入输入张量来运行模型，并获得输出结果。在这个示例中，我们简单地将输出结果打印出来，但实际上您可以根据您的应用程序需求来处理输出结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值