网络编程二：UDP通信过程+非阻塞IO属性

最新推荐文章于 2024-05-03 21:43:52 发布
最新推荐文章于 2024-05-03 21:43:52 发布
阅读量804 收藏 3
点赞数
分类专栏： Linux网络编程 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53809203/article/details/132921711
版权

一、UDP协议

1、UDP协议中由于不需要连接，所以不能使用accept/connect函数。
2、UDP中是如何知道对方的地址？？？
    在TCP中，先连接，所以connect(对方的IP地址和端口号)/accpet(客户端的IP地址和端口号)
    在UDP中，地址和端口号 这些信号 只能与 数据 一起发送过去，所以接收的时候 地址和端口号 以及数据 一起接收
3、一定要区分 TCP 和 UDP 所使用的接口不一样，不要混淆了    

TCP:  
    客户端：socket(SOCK_STREAM)  (bind)  connect  send  recv  close 
    服务器：socket(SOCK_STREAM)  bind  listen   accept  recv send close 

UDP: 
    客户端： socket(SOCK_DGRAM)  (bind) sendto  recvfrom close 
    服务器： socket(SOCK_DGRAM)  bind recvfrom sendto close

二、UDP实现过程

客户端

1、建立套接字（选择UDP协议）

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

    int socket(int domain, int type, int protocol);

函数作用：建立套接字

参数： 
    domain：你要选择哪一种地址族 
            PF_INET/AF_INET ------Ipv4 网络协议
            PF_INET6/AF_INET6----- Ipv6 网络协议
    type：  你要选择哪一种 协议（TCP  UDP）
            SOCK_STREAM --流式套接字 TCP 
            SOCK_DGRAM -数据报套接字  UDP 
    protocol:一般设置成 0
    
返回值： 
        成功返回  套接字文件描述符 
        失败  -1

2、绑定自己的IP地址和端口号 

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

    int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    
参数：    
        sockfd：套接字文件描述符
        addr:自己的IP地址和端口号 
        addrlen：结构体的大小 
        
返回值 ：
        成功则返回 0, 
        失败返回-1, 错误原因存于 errno 中
        
struct sockaddr  --旧的结构体
{
    unsigned short sa_family; /*地址族*/
    char sa_data[14];/*14字节的协议地址，包含该socket的IP地址和端口号。*/
};    

//IPV4结构体      
struct sockaddr_in 
{
    short int sin_family; /*地址族  IPV4   IPV6*/
    unsigned short int sin_port; /*端口号*/
    struct in_addr sin_addr; /*IP地址*/
    unsigned char sin_zero[8]; /*填充0 以保持与struct sockaddr同样大小*/
};
struct in_addr { 
    in_addr_t s_addr; /*in_addr_t为 32位的unsigned int，该无符号整数采用大端字节序。*/
};    


3、直接发送（聊天）

#include <sys/socket.h>

ssize_t sendto(int socket, const void *message, size_t length,int flags, const struct sockaddr *dest_addr,socklen_t dest_len);

函数作用： 用于UDP中发送数据，注意是UDP

参数： 
        socket ：套接字文件描述符 
        message：你要发送的数据 
        length：你要发送的数据大小，注意有多少就发多少 strlen
        flags：一般设置成 0 
        dest_addr：对方的IP地址和端口号
        dest_len：结构体的大小

返回值： 
        成功返回 发送出去的字节数
        失败返回 -1


4、关闭 
    close(socketfd);

服务器端

#include <sys/socket.h>

ssize_t recvfrom(int socket, void * buffer, size_t length,int flags, struct sockaddr * address, socklen_t * address_len);

函数作用：用于UDP中接收数据

参数： 
        socket ：套接字文件描述符 
        buffer：接收的数据存储在这里
        length：接收的数据的大小， 以最大的来接收 sizeof()
        flags：一般设置成 0 
        address: 存储 客户端的IP地址和端口号 ，可以获取到是 谁 给你 发送的 
        address_len：结构体的大小

返回值： 
        成功返回 接收到的字节数
        失败返回 -1

三、练习1

修改UDP通信的代码，实现互相聊天

1、UDP发送端.c

#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>          /* See NOTES */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>


#define  OWNADDR  "192.168.14.3"  //我自己ubuntu的ip地址
#define  OWNPORT  20000 //我自己ubuntu的该程序的端口号

#define  SERVERADDR "192.168.14.3"//服务器的IP地址 也就是  对方的 
#define  SERVERPORT  10000  //服务器的端口号  也就是  对方的 

int main()
{
	//1、建立套接字（选择UDP协议 一定要选择这个 SOCK_DGRAM）
	int socketfd = socket(AF_INET,SOCK_DGRAM,0);
	if(socketfd == -1)
	{
		printf("socketfd error\n");
		return -1;
	}
	//2、绑定自己的IP地址和端口号 ---这一步在客户端 可以省略
	struct sockaddr_in ownAddr;//定义一个IPV4结构体变量，初始化自己的信息
	ownAddr.sin_family = AF_INET;//IPV4
	ownAddr.sin_port = htons(OWNPORT); /*端口号*/
	ownAddr.sin_addr.s_addr = inet_addr(OWNADDR);//本地IP-->网络IP
	
	bind(socketfd,(struct sockaddr *)&ownAddr,sizeof(struct sockaddr_in));
	
	//定义一个IPV4结构体变量，存储对方的IP地址和端口号
	struct sockaddr_in serverAddr;
	serverAddr.sin_family = AF_INET;//IPV4
	serverAddr.sin_port = htons(SERVERPORT); /*端口号*/
	serverAddr.sin_addr.s_addr = inet_addr(SERVERADDR);//本地IP-->网络IP

	
	//3、直接发送（聊天）
	while(1)
	{
		char buf[1024]={0};
		printf("data:");
		scanf("%s",buf);
		
		sendto(socketfd,buf,strlen(buf),0,(struct sockaddr *)&serverAddr,sizeof(struct sockaddr_in));

	}
	
	//4、关闭 
	close(socketfd);
	
	return 0;
}

2、UDP接收端.c

#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>          /* See NOTES */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>


#define  OWNADDR  "192.168.14.3"  //我自己ubuntu的ip地址
#define  OWNPORT  10000 //我自己ubuntu的该程序的端口号

#define  SERVERADDR "192.168.14.3"//服务器的IP地址 也就是  对方的 
#define  SERVERPORT  10000  //服务器的端口号  也就是  对方的 

int main()
{
	//1、建立套接字（选择UDP协议 一定要选择这个 SOCK_DGRAM）
	int socketfd = socket(AF_INET,SOCK_DGRAM,0);
	if(socketfd == -1)
	{
		printf("socketfd error\n");
		return -1;
	}
	//2、绑定自己的IP地址和端口号 ---这一步在客户端 可以省略
	struct sockaddr_in ownAddr;//定义一个IPV4结构体变量，初始化自己的信息
	ownAddr.sin_family = AF_INET;//IPV4
	ownAddr.sin_port = htons(OWNPORT); /*端口号*/
	ownAddr.sin_addr.s_addr = inet_addr(OWNADDR);//本地IP-->网络IP
	
	bind(socketfd,(struct sockaddr *)&ownAddr,sizeof(struct sockaddr_in));
	
	//定义一个IPV4结构体变量，存储对方的IP地址和端口号
	struct sockaddr_in otherAddr;
	int len = sizeof(struct sockaddr_in);//一定要指定大小，作为参数传递进去
	
	//3、直接接收数据（聊天）
	while(1)
	{
		char buf[1024]={0};

		int ret = recvfrom(socketfd,buf,sizeof(buf),0, (struct sockaddr *)&otherAddr,&len);
		if(ret <=0)
			break;
		
		printf("来自[%s]:[%u]:%s\n",inet_ntoa(otherAddr.sin_addr),ntohs(otherAddr.sin_port),buf); //buf: li4给gebi    "hello" + 192.168.14.20
	}
	
	//4、关闭 
	close(socketfd);
	
	return 0;
}

四、练习2

1、UDP发送端+多线程.c

#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>          /* See NOTES */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>
 #include <unistd.h>
#define  OWNADDR  "192.168.14.3"  //我自己ubuntu的ip地址
#define  OWNPORT  20000 //我自己ubuntu的该程序的端口号

#define  SERVERADDR "192.168.14.3"//服务器的IP地址 也就是  对方的 
#define  SERVERPORT  10000  //服务器的端口号  也就是  对方的 


void * start_routine(void *arg)
{
	int socketfd = *((int*)arg);//强转类型 并且解引用 得到socketfd
	//定义一个IPV4结构体变量，存储对方的IP地址和端口号
	struct sockaddr_in otherAddr;
	int len = sizeof(struct sockaddr_in);//一定要指定大小，作为参数传递进去
	
	//接收服务器的数据
	while(1)
	{
		char buf[1024]={0};

		int ret = recvfrom(socketfd,buf,sizeof(buf),0, (struct sockaddr *)&otherAddr,&len);
		if(ret <=0)
			break;
		
		printf("来自[%s]:[%u]:%s\n",inet_ntoa(otherAddr.sin_addr),ntohs(otherAddr.sin_port),buf); //buf: li4给gebi    "hello" + 192.168.14.20
	}
	
	pthread_exit(NULL);
}

int main()
{
	//1、建立套接字（选择UDP协议 一定要选择这个 SOCK_DGRAM）
	int socketfd = socket(AF_INET,SOCK_DGRAM,0);
	if(socketfd == -1)
	{
		printf("socketfd error\n");
		return -1;
	}
	//2、绑定自己的IP地址和端口号 ---这一步在客户端 可以省略
	struct sockaddr_in ownAddr;//定义一个IPV4结构体变量，初始化自己的信息
	ownAddr.sin_family = AF_INET;//IPV4
	ownAddr.sin_port = htons(OWNPORT); /*端口号*/
	ownAddr.sin_addr.s_addr = inet_addr(OWNADDR);//本地IP-->网络IP
	
	bind(socketfd,(struct sockaddr *)&ownAddr,sizeof(struct sockaddr_in));
	
	//定义一个IPV4结构体变量，存储对方的IP地址和端口号
	struct sockaddr_in serverAddr;
	serverAddr.sin_family = AF_INET;//IPV4
	serverAddr.sin_port = htons(SERVERPORT); /*端口号*/
	serverAddr.sin_addr.s_addr = inet_addr(SERVERADDR);//本地IP-->网络IP

	//创建一个子线程，用来接收
	pthread_t thread;
	pthread_create(&thread,NULL,start_routine,&socketfd);
	
	//3、直接发送（聊天）
	while(1)
	{
		char buf[1024]={0};
		printf("data:");
		scanf("%s",buf);
		
		sendto(socketfd,buf,strlen(buf),0,(struct sockaddr *)&serverAddr,sizeof(struct sockaddr_in));

	}
	
	//4、关闭 
	close(socketfd);
	
	return 0;
}

2、UDP接收端+多线程.c

#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>          /* See NOTES */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>
 #include <unistd.h>
 
#define  OWNADDR  "192.168.14.3"  //我自己ubuntu的ip地址 --服务器
#define  OWNPORT  10000 //我自己ubuntu的该程序的端口号  --服务器

#define  OTHERADDR "192.168.14.3"//对方的IP地址  --客户端
#define  OTHERPORT  20000  //对方的端口号   --客户端

void * start_routine(void *arg)
{
	int socketfd = *((int*)arg);//强转类型 并且解引用 得到socketfd
	
	//定义一个IPV4结构体变量，存储对方的IP地址和端口号
	struct sockaddr_in otherAddr;
	otherAddr.sin_family = AF_INET;//IPV4
	otherAddr.sin_port = htons(OTHERPORT); /*端口号*/
	otherAddr.sin_addr.s_addr = inet_addr(OTHERADDR);//本地IP-->网络IP

	//3、直接发送（聊天）
	while(1)
	{
		char buf[1024]={0};
		printf("data:");
		scanf("%s",buf);
		
		sendto(socketfd,buf,strlen(buf),0,(struct sockaddr *)&otherAddr,sizeof(struct sockaddr_in));
	}
	
	pthread_exit(NULL);
}

int main()
{
	//1、建立套接字（选择UDP协议 一定要选择这个 SOCK_DGRAM）
	int socketfd = socket(AF_INET,SOCK_DGRAM,0);
	if(socketfd == -1)
	{
		printf("socketfd error\n");
		return -1;
	}
	//2、绑定自己的IP地址和端口号 ---这一步在客户端 可以省略
	struct sockaddr_in ownAddr;//定义一个IPV4结构体变量，初始化自己的信息
	ownAddr.sin_family = AF_INET;//IPV4
	ownAddr.sin_port = htons(OWNPORT); /*端口号*/
	ownAddr.sin_addr.s_addr = inet_addr(OWNADDR);//本地IP-->网络IP
	
	bind(socketfd,(struct sockaddr *)&ownAddr,sizeof(struct sockaddr_in));
	
	//定义一个IPV4结构体变量，存储对方的IP地址和端口号
	struct sockaddr_in otherAddr;
	int len = sizeof(struct sockaddr_in);//一定要指定大小，作为参数传递进去
	
	//创建一个子线程，用来发送数据
	pthread_t thread;
	pthread_create(&thread,NULL,start_routine,&socketfd);
	
	//3、直接接收数据（聊天）
	while(1)
	{
		char buf[1024]={0};

		int ret = recvfrom(socketfd,buf,sizeof(buf),0, (struct sockaddr *)&otherAddr,&len);
		if(ret <=0)
			break;
		
		printf("来自[%s]:[%u]:%s\n",inet_ntoa(otherAddr.sin_addr),ntohs(otherAddr.sin_port),buf); //buf: li4给gebi    "hello" + 192.168.14.20
	}
	
	//4、关闭 
	close(socketfd);
	
	return 0;
}

五、socket编程中四种IO模型

1、阻塞IO(重点)

1）read(fd)  recv(socketfd)  recvfrom(socketfd) ...
    这些函数本身是不具有阻塞属性，而是因为这个文件描述符的本身阻塞属性导致这个函数执行表现出来的效果是阻塞。
2）在默认的情况下，linux中建立的套接字 、文件描述符 都是 阻塞的。

2、非阻塞IO

1）给文件描述符添加非阻塞属性。
2）由于非阻塞属性，所以可以不断地询问套接字中是否有数据到达。

3、多路复用    (重点)

1）同时对多个IO口（文件描述符）进行操作（同时监听多个套接字）
2）可以在规定的时间内检测数据是否到达

4、信号驱动

1）属于异步通信方式
2）当socket中有数据到达时，通过发送信号通知用户

六、阻塞IO

读阻塞：当数据缓冲区中没有数据可以读取时，调用 read  recv recvfrom  scanf    就会无限阻塞。
    写阻塞：当数据缓冲区剩余的大小 小于 写入的数据量（你的空间不够写了），就会发生写阻塞，直到缓冲区的数据被读取。

    例子： int fd = open("xxxx"); --->fd是阻塞。。
                如果使用   O_NONBLOCK  该宏打开的 文件，那么文件描述符是非阻塞。

七、非阻塞IO 

1、阻塞IO 与 非阻塞IO之间的区别

    阻塞IO 
            建立套接字（阻塞）----》读取数据---》判断缓冲区中没有数据 
            
                ————没有数据--》进入一个等待的状态---》直到缓冲区中 有数据为止。
                ---来数据了---》读取数据 --》进入一个等待的状态---》直到缓冲区中 有数据为止。
                
    非阻塞IO 
            建立套接字（阻塞）--》将这个套接字文件描述符的属性设置为非阻塞状态---》读取数据 --》
            
                ---没有数据---》读取失败---》接口会马上返回，不会阻塞
                ---》有数据 ---》读取成功--》接口也会返回 

2、如何给文件描述符设置 非阻塞属性    ---file  control     fcntl

    #include <unistd.h>
    #include <fcntl.h>

    int fcntl(int fd, int cmd, ... /* arg */ );
            
                
参数： 
        fd :你要设置哪个文件描述符，将这个文件描述符传递进来
        cmd：控制的命令
        arg：由第二个参数进行决定
        
第二个参数cmd:
        

F_GETFL: Get the file status flags and file access modes, 可以得到文件描述符的状态 ,第三个参数可以忽略

 F_SETFL: 设置文件描述符的状态，但只允许 O_APPEND、O_NONBLOCK 和O_ASYNC 位的改变, 其他位的改变将不受影响.

                O_APPEND： 可以设置成 追加 
                O_NONBLOCK：可以设置 非阻塞属性

返回值 ： 
        F_GETFL --》返回 文件描述符的状态或者属性
        F_SETFL --> 
                    成功返回 0 
                    失败返回 -1


                    
比如： 
        int socketfd = socket(TCP协议);//默认是阻塞的
        //得到这个套接字文件描述符的属性
        int status = fcntl(socketfd,F_GETFL)
        //将得到的文件描述符的全部属性 中的 其中一个属性设置成 非阻塞 
        status |= O_NONBLOCK;
        fcntl(socketfd,F_SETFL,status);//把变量status的状态设置到文件描述符中

八、例子

设置一个非阻塞属性 给套接字，看看这个套接字 是否 还会阻塞等待客户端的连接。

#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>          /* See NOTES */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#define  OWNADDR  "192.168.14.3"  //我自己电脑的ip地址
#define  OWNPORT  20000 //我自己电脑的该程序的端口号

int main()
{
	printf("当前是服务器 IP:%s Port:%u\n",OWNADDR,OWNPORT);
	//1、买手机（建立套接字）
	int socketfd = socket(AF_INET, SOCK_STREAM, 0);
	if(socketfd == -1)
	{
		printf("没钱了....,失败\n");
		return -1;
	}
	//因为服务器立马退出之后，端口号不会及时释放
	//此时如果服务器又马上运行，那么端口号会被占用，导致服务器分配端口号失败，连接失败
	//所以设置端口号可以复用
	int optval = 1;
	setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval));
	
	//2、绑定自己的电话号码（绑定自己的IP地址 和端口号）
	//定义一个IPV4结构体变量，初始化自己的IP地址和端口号
	struct sockaddr_in ownAddr;
	ownAddr.sin_family = AF_INET;/*地址族  IPV4*/
	ownAddr.sin_port = htons(OWNPORT); //htons 将本地端口号转为网络端口号
	ownAddr.sin_addr.s_addr = inet_addr(OWNADDR); //将本地IP地址转为网络IP地址
	
	bind(socketfd, (struct sockaddr *)&ownAddr,sizeof(struct sockaddr_in));
	
	//3、设置铃声(监听) listen
	listen(socketfd,5);
	
	//4、坐等电话（阻塞接收客户端的连接）
	printf("等待客户端连接.......\n");
	//定义一个IPV4结构体变量，存储连接上来的客户端的IP地址 和 端口号 
	struct sockaddr_in clientAddr;
	//如果你要想要获取对方的IP地址和端口号，第三个参数必须把结构体的大小传递进去
	int len = sizeof(struct sockaddr_in);
	
	//给 socketfd设置非阻塞属性 
	int status = fcntl(socketfd,F_GETFL);//得到这个套接字文件描述符的属性
	//将得到的文件描述符的全部属性 中的 其中一个属性设置成 非阻塞 
	status |= O_NONBLOCK;
	int ret = fcntl(socketfd,F_SETFL,status);//把变量status的状态设置到文件描述符中
	if(ret == -1)
	{
		printf("fcntl error\n");

	}
	while(1)
	{
		//此时是非阻塞，会一直不断地循环
		int newClientFd = accept(socketfd,(struct sockaddr*)&clientAddr,&len);
		if(newClientFd != -1)
		{
			//printf("有客户端连接上来了............\n");
			//打印连接上来的客户端的IP地址和端口号，将网络字节序转为 本地字节序
			printf("连接上来的客户端IP:%s 端口号:%u\n",inet_ntoa(clientAddr.sin_addr),ntohs(clientAddr.sin_port));
		}
		//printf("11111111111\n");	
	}
	
	//5、关闭 
	close(socketfd);
	//close(newClientFd);
	
	return 0;
}

九、练习

写一个服务器，可以接受多个客户端的连接 ，可以随时接受连接。

        只要连接上服务器的客户端由数据到达的时候，还要把数据打印出来，要求使用非阻塞的方式去实现。

第一种方式： 使用数组 

            struct client{
                int clientfd[100]; //已连接上来的客户端的套接字文件描述符
                int count; //已连接用户的总数
            }
            
第二种方式： 使用链表 
            连接上来一个客户---》新建结点 ---》将客户的套接字文件描述符存储到链表中 
            
            
        
        while(1)
        {
            //此时是非阻塞，会一直不断地循环
            int newClientFd = accept(socketfd,(struct sockaddr*)&clientAddr,&len);
            if(newClientFd != -1)
            {
                //printf("有客户端连接上来了............\n");
                //打印连接上来的客户端的IP地址和端口号，将网络字节序转为 本地字节序
                printf("连接上来的客户端IP:%s 端口号:%u\n",inet_ntoa(clientAddr.sin_addr),ntohs(clientAddr.sin_port));
                //连接上来的客户端的套接字文件描述符  添加到 数组  或者 链表 中 
            }
            //看看有没有已连接上来的客户端的套接字有数据变化 ，如果有，那么把数据打印出来
            
        }

/*
练习2：写一个服务器，可以接受多个客户端的连接 ，可以随时接受连接。
		只要连接上服务器的客户端由数据到达的时候，还要把数据打印出来，要求使用非阻塞的方式去实现。
		
第一种方式： 使用数组 

			struct client{
				int clientfd[100]; //已连接上来的客户端的套接字文件描述符
				int count; //已连接用户的总数
			}
*/
#include<stdio.h>
#include <sys/socket.h>
#include <sys/types.h>          /* See NOTES */
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>


#define  OWNADDR  "192.168.14.3"  //我自己电脑的ip地址
#define  OWNPORT  20000 //我自己电脑的该程序的端口号

//设计一个结构体数据类型
struct client{
	int clientfd[100]; //已连接上来的客户端的套接字文件描述符
	int count; //已连接用户的总数
};

//定义一个结构体变量,存储和管理连接上来的客户端
struct client clientManager;

void initManager()
{
	//初始化
	int i;
	for(i=0; i<100; i++)
	{
		clientManager.clientfd[i] = -1;//-1代表该位置是空的
	}
	clientManager.count = 0;//刚开始的时候没有客户端连接，那就是0
}

int main()
{
	int i;
	initManager();
	
	printf("服务器的IP地址:%s 端口号:%u\n",OWNADDR,OWNPORT);
	
	//1、买手机（建立套接字）
	int socketfd = socket(AF_INET, SOCK_STREAM, 0);
	if(socketfd == -1)
	{
		printf("没钱了....,失败\n");
		return -1;
	}
	//因为服务器立马退出之后，端口号不会及时释放
	//此时如果服务器又马上运行，那么端口号会被占用，导致服务器分配端口号失败，连接失败
	//所以设置端口号可以复用
	int optval = 1;
	setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval));
	
	//2、绑定自己的电话号码（绑定自己的IP地址 和端口号）
	//定义一个IPV4结构体变量，初始化自己的IP地址和端口号
	struct sockaddr_in ownAddr;
	ownAddr.sin_family = AF_INET;/*地址族  IPV4*/
	ownAddr.sin_port = htons(OWNPORT); //htons 将本地端口号转为网络端口号
	ownAddr.sin_addr.s_addr = inet_addr(OWNADDR); //将本地IP地址转为网络IP地址
	
	bind(socketfd, (struct sockaddr *)&ownAddr,sizeof(struct sockaddr_in));
	
	//3、设置铃声(监听) listen
	listen(socketfd,5);
	
	//定义一个IPV4结构体变量，存储连接上来的客户端的IP地址 和 端口号 
	struct sockaddr_in clientAddr;
	//如果你要想要获取对方的IP地址和端口号，第三个参数必须把结构体的大小传递进去
	int len = sizeof(struct sockaddr_in);
	
	//socketfd 设置成非阻塞属性
	int status = fcntl(socketfd,F_GETFL);//得到这个套接字文件描述符的属性
	//将得到的文件描述符的全部属性 中的 其中一个属性设置成 非阻塞 
	status |= O_NONBLOCK;
	fcntl(socketfd,F_SETFL,status);//把变量status的状态设置到文件描述符中

	
	while(1)
	{
		//4、坐等电话（阻塞接收客户端的连接）
		int newClientFd = accept(socketfd,(struct sockaddr*)&clientAddr,&len);
		if(newClientFd != -1)
		{
			printf("有客户端连接上来了............\n");
			//打印连接上来的客户端的IP地址和端口号，将网络字节序转为 本地字节序
			printf("连接上来的客户端IP:%s 端口号:%u\n",inet_ntoa(clientAddr.sin_addr),ntohs(clientAddr.sin_port));
			//将已经连接上来的客户端的新的文件描述符 存储到数组中
			
			//newClientFd设置为非阻塞属性
			int status = fcntl(newClientFd,F_GETFL);//得到这个套接字文件描述符的属性
			//将得到的文件描述符的全部属性 中的 其中一个属性设置成 非阻塞 
			status |= O_NONBLOCK;
			fcntl(newClientFd,F_SETFL,status);//把变量status的状态设置到文件描述符中

			clientManager.clientfd[clientManager.count++] = newClientFd;
		}
		//检查已经连接上来的客户端有没有数据发送过来
		for(i=0; i<clientManager.count;i++)
		{
			char buf[1024]={0};
			//重点重点重点：recv 一定是使用 已经连接上来的新客户端的套接字文件描述符 newClientFd
			int ret = recv(clientManager.clientfd[i],buf,sizeof(buf),0);
			if(ret == 0)//代表客户端退出 
			{
				printf("客户端退出.....\n");	
				//如果你是用的链表，那么客户端退出之后，把客户端对应的该结点删除掉
				break;
			}
			else if(ret >0)//有数据过来的时候才打印
			{
				printf("recv:%s\n",buf);
			}
		}
	}

	//5、关闭 
	close(socketfd);
	//close(newClientFd);
	
	return 0;
}

扩展： 
        (使用UDP通信)
        服务器作为 数据的 中转站 负责 转发 数据  
        
        比如 客户端 [li4] 给客户端[laowang] 发送信息"想你"  
        
        思路 ： 首先客户端[li4] 给服务器发送数据 ：laowang的IP地址和端口号 + 数据  ---》服务器收到之后 解析数据 ，把 laowang的IP地址和端口号 解析出来 ---》服务器 把 数据  转发 给 laowang

阿哈、小吴
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
popol：Rust的最小非阻塞IO
02-04
Popol是Rust编程语言中一个专注于非阻塞I/O（Input/Output）的库，它的设计目标是提供一种简洁且高效的解决方案，用于构建高性能的网络应用，特别是那些需要处理大量并发连接的服务。非阻塞I/O是网络编程中的一个...
Windows网络编程之（二）Socket通信非阻塞模式Select（TCP和UDP）
燈火闌珊處
08-14 5417
阻塞式的Socket很容易理解，但是使用起来非常别扭。Windows提供了选择（Select）I/O模型，进行异步Socket通信. Select模型 int select( _In_ int nfds,//忽略. 此参数为了与Berkeley sockets兼容. _Inout_ fd_set *readfds,//检查可读性fd_set指针. _Inout_ f
C++ Windows非阻塞UDP通信源码
ThinkOver33 CSDN Blog
11-16 5754
UDP通信中，recvfrom或recv等函数默认都是阻塞方式进行的，即如果没有收到消息，那么程序会一直卡在recv()这个函数这里，使得该线程不能进行后续的操作。但有时候我们需要该线程在有UDP数据发送过来的时候才进行数据接收，而在其他时间该线程还有别的任务进行处理，那么我们就需要将Sokcet设置为非阻塞通信的方式。非阻塞通信中，需要用到select()函数，select函数用于在非阻塞中，当一
UDP编程流程（UDP客户端、服务器互发消息流程）
最新发布
BEIFEN13的博客
05-03 2798
UDP编程-创建套接字、发送、绑定、接收数据，UDP客户端和 UDP服务器
linux socket read 阻塞
molibaobei90的专栏
10-25 1012
read函数只是一个通用的读文件设备的接口。是否阻塞需要由设备的属性和设定所决定。一般来说，读字符终端、网络的socket描述字，管道文件等，这些文件的缺省read都是阻塞的方式。如果是读磁盘上的文件，一般不会是阻塞方式的。但使用锁和fcntl设置取消文件O_NOBLOCK状态，也会产生阻塞的read效果。 怎么样以非阻塞的方式从管道中读取数据？因为我用read函数时，如果管道没有数据就会阻塞住
基于UDP的非阻塞通信
qq2071114140的博客
07-21 2626
基于UDP的非阻塞通信 如果使用UDP进行阻塞通信，则会在receive()时阻塞（在没有报文到达时）。 如果使用非阻塞通信，就需要“知道”什么时候调用receive()，与基于TCP的非阻塞通信相同，需要一个selector来监听管道的“事件”。当有报文到达时，事件触发。 通过selector，在事件触发时调用receive()接收报文即可。 通信流程 1. 创建DatagramChannel DatagramChannel datagramChannel = DatagramChannel.open()
UDP服务recvfrom函数设置非阻塞
曾立文的博客
05-08 1万+
本文先介绍我查看了的2篇文章，然后介绍linux 和windows 下的非阻塞设置。最后是非阻塞情况下接收情况的判断。 2篇博文 其实UDP的非阻塞也可以理解成和TCP是一样的，都是通过socket的属性去做。 方法一：通过fcntl函数将套接字设置为非阻塞模式。 方法二：通过套接字选项SO_RECVTIMEO设置超时。 https://blog.csdn.net/daiyudong20...
TCP、UDP的阻塞和非阻塞模式
lzg_na的博客
08-24 8304
前言 socket在默认情况下是阻塞状态的，这就使得发送和接受都处于阻塞状态; TCP协议下发送选用send，UDP协议下，发送选用sendto. TCP协议下接收选用recv，UDP协议下，接收选用recvfrom. 一、阻塞模式&&send 假设发送缓冲区大小为4096KB,其中已经使用4000KB空间，剩余96KB空间；现在又有200KB的数据需要发送，则只能先将96KB的数据放入发送缓冲区但不发送（阻塞），直到缓冲区空出空间足够放入剩余104KB，再send操作将这200子节发送
window下c/c++异步发送udp和非阻塞的方式接收udp的类封装
xsy29000的博客
12-02 4658
以下代码对udp发送和接收都做了封装，在发送和接收前都需要去注册使用的功能，从而做到需要哪个模块才启动哪个模块的功能，避免资源的浪费。 udp发送功能:使用列表和信号量的方式实现异步发送数据，避免主线程发送数据时出现阻塞的情况 udp接收功能:使用select函数可以实现非阻塞方式接收，避免主线程接收数据需要阻塞等待消息的到来 更详细的说明在代码的注释中,如发现问题欢迎批评指正~ udp.h #p...
非阻塞IO+Proactor+日志系统 自定义协议服务器.zip
05-29
综上所述，"非阻塞IO+Proactor+日志系统 自定义协议服务器"项目涉及的关键技术点包括： 1. 非阻塞I/O：提高并发处理能力，减少线程间的上下文切换。 2. Proactor模式：通过事件驱动的异步I/O，简化多并发情况下的...
Linux Socket编程、Linux IO模型、Linux 进程间通信完整用例
02-16
在Linux中，有五种主要的IO模型：阻塞IO、非阻塞IO、IO复用（如select、poll、epoll）、信号驱动IO和异步IO。每种模型都有其适用场景和优缺点。例如，阻塞IO简单易用，但会阻塞进程直到数据准备就绪；非阻塞IO不会...
工作流程：C ++并行计算和异步网络引擎
02-03
它处理I/O操作（如读写网络流）的非阻塞方式，使得单个线程能够处理多个并发连接。C++11引入了异步I/O模型，如std::async和std::future，以及std::promise/future组合，它们提供了异步操作的基础。此外，Boost.Asio...
【Python网络编程】服务端和客户端通信，附详细注释
08-15
2. 异步IO：Python的`asyncio`库提供了一种更高效的处理方式，通过事件循环和协程实现非阻塞I/O，从而提高服务端性能。 三、爬虫源码 Python在网络爬虫方面也有广泛的应用。`requests`库是常用的HTTP请求库，而`...
高性能UDP接收， 不丢包，win API 版本
TuringEvo专栏
07-29 1132
高性能UDP接收， 不丢包，win API 版本 非阻塞方式连接 由于采用阻塞模式，在没有数据的情况下会等待，这里我们接收立即返回，采用非阻塞模式 //设置非阻塞方式连接 unsigned long ul = 1; int ret = ioctlsocket(sock, FIONBIO, (unsigned long*)&ul); if (ret != NO_ERROR){ printf("ioctlsocket f
Linux Socket网络编程UDP、TCP 阻塞与非阻塞 断线重连机制
qq_42475191的博客
09-12 6050
一·、UDP协议及其工作原理 (10条消息) UDP.01.基础知识+基础模型_老毛的博客-CSDN博客 (10条消息) Socket原理讲解_Tony-jiang的博客-CSDN博客_socket 二、UDP在Linux下的编程方式 2.1 参考链接： (10条消息) UDP的编程流程_liqiao_418的博客-CSDN博客_udp流程 (10条消息) UDP编程步骤_judgejames的博客-CSDN博客_udp过程 2.2 编程流程 服务端： //1.创建套接字 #inclu
QUdpSocket服务端接收数据说明(非阻塞)
SUST_DOG_MASTER博客
09-23 2470
先说结论吧,QUdpSocket不支持阻塞式访问，正常非阻塞的要么需要信号槽机制访问，要么需要循环判断，导致的结果就是要不丢包严重，要不CPU占用率高，还是建以利用socket自己去实现UDP。 参考：QT中UDPSocket丢包问题_rabbitjerry的专栏-CSDN博客_qt udp丢包 1.信号槽机制访问 #include <QCoreApplication> #include <QUdpSocket> #include <QHostAddress&g
C++中UDP通讯详解
热门推荐
u011555996的博客
09-20 1万+
C++
[MFC]UDP通信的简单实现
Lirx_Tech的专栏
07-21 1万+
1. UDP和TCP最大的区别：      1) TCP最大的特点就是面向连接、安全可靠，也就是说TCP通信必须要先建立连接，并且通信过程需要时时校验，如果数据有误需要重发；      2) UDP最大的特点就是面向无连接，不可靠，也就是说不用建立连接就直接向目标发送信息，并且通信过程中不做任何校验，如果数据丢失或者有误也不管；      3) 听上去UDP非常的无用，但其实不然，UDP最大
linux网络编程知识点
05-12
Linux网络编程主要涉及以下知识点： 1. Socket编程：Socket是一种通用的网络通信协议，Linux通过Socket实现网络编程。Socket编程可以分为TCP和UDP两种。 2. TCP/IP协议：TCP/IP协议是一种网络通信协议，它是互联网的基础协议。Linux使用TCP/IP协议来实现网络通信。 3. IP地址和端口号：IP地址是唯一标识一个网络设备的地址，端口号是进程与网络之间的通信接口。Linux使用IP地址和端口号来实现网络通信。 4. select/poll/epoll：这些是Linux下的I/O多路复用机制，可以用来监控多个文件描述符的状态，从而提高网络编程的效率和可靠性。 5. 线程和进程：线程是进程中的执行单元，可以实现多线程编程来提高网络编程的并发能力。 6. DNS解析：DNS解析是将域名转换为IP地址的过程，Linux提供了一些函数来实现DNS解析。 7. Socket选项：Linux提供了一些Socket选项，可以控制Socket的行为和属性，如SO_REUSEADDR、SO_KEEPALIVE等。 8. 套接字编程模型：Linux下的套接字编程模型包括阻塞式和非阻塞式两种模式，以及IO多路复用模式。 9. 网络协议栈：Linux下的网络协议栈由多个协议组成，包括IP协议、TCP协议、UDP协议等。 以上是Linux网络编程的一些主要知识点，掌握这些知识点可以帮助开发者更好地理解和应用网络编程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值