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

最新推荐文章于 2024-05-25 21:47:48 发布
最新推荐文章于 2024-05-25 21:47:48 发布
阅读量854 收藏 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
    评论
专栏目录
基于UDP的非阻塞通信
qq2071114140的博客
07-21 2641
基于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...
linux socket read 阻塞
molibaobei90的专栏
10-25 1026
read函数只是一个通用的读文件设备的接口。是否阻塞需要由设备的属性和设定所决定。一般来说，读字符终端、网络的socket描述字，管道文件等，这些文件的缺省read都是阻塞的方式。如果是读磁盘上的文件，一般不会是阻塞方式的。但使用锁和fcntl设置取消文件O_NOBLOCK状态，也会产生阻塞的read效果。 怎么样以非阻塞的方式从管道中读取数据？因为我用read函数时，如果管道没有数据就会阻塞住
TCP和UDP阻塞和非阻塞之间的区别
最新发布
诗筱涵的博客
05-25 83
我在网络上看到某些人说，阻塞就是将数据真正发送给对方，并且阻塞是发生在需要把前面的所有数据全部发送出去，然后再发送本次的，而非阻塞则是拷贝到发送缓冲区。我不得不说，上面的这种说法是错误的。man 一下 send，发现man里有描述容易误导，send() shall fail.应该是需要自己判断的，会返回实际发送成功的字节，想全部成功发送，需要自己实现一遍阻塞循环发送的逻辑，当多端口*大包发送的时候，可以非阻塞拆包发送（循环每个端口send一次小包，避免单个端口阻塞很久），效果会比阻塞的好很多。
window下c/c++异步发送udp和非阻塞的方式接收udp的类封装
xsy29000的博客
12-02 4704
以下代码对udp发送和接收都做了封装，在发送和接收前都需要去注册使用的功能，从而做到需要哪个模块才启动哪个模块的功能，避免资源的浪费。 udp发送功能:使用列表和信号量的方式实现异步发送数据，避免主线程发送数据时出现阻塞的情况 udp接收功能:使用select函数可以实现非阻塞方式接收，避免主线程接收数据需要阻塞等待消息的到来 更详细的说明在代码的注释中,如发现问题欢迎批评指正~ udp.h #p...
TCP、UDP的阻塞和非阻塞模式
lzg_na的博客
08-24 8390
前言 socket在默认情况下是阻塞状态的，这就使得发送和接受都处于阻塞状态; TCP协议下发送选用send，UDP协议下，发送选用sendto. TCP协议下接收选用recv，UDP协议下，接收选用recvfrom. 一、阻塞模式&&send 假设发送缓冲区大小为4096KB,其中已经使用4000KB空间，剩余96KB空间；现在又有200KB的数据需要发送，则只能先将96KB的数据放入发送缓冲区但不发送（阻塞），直到缓冲区空出空间足够放入剩余104KB，再send操作将这200子节发送
popol：Rust的最小非阻塞IO
02-04
Popol是Rust编程语言中一个专注于非阻塞I/O（Input/Output）的库，它的设计目标是提供一种简洁且高效的解决方案，用于构建高性能的网络应用，特别是那些需要处理大量并发连接的服务。非阻塞I/O是网络编程中的一个...
Netty初探：掌握高性能网络通信框架，提升Java网络编程技能
01-05
3. **减少资源消耗**：通过事件驱动和异步非阻塞模型，有效减少了线程资源的消耗。 4. **内存管理**：Netty 使用零拷贝技术，最小化了不必要的内存复制，提升了性能。 学习和掌握Netty，可以提升Java网络编程能力，...
非阻塞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...
Linux Socket网络编程UDP、TCP 阻塞与非阻塞 断线重连机制
qq_42475191的博客
09-12 6166
一·、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 2507
先说结论吧,QUdpSocket不支持阻塞式访问，正常非阻塞的要么需要信号槽机制访问，要么需要循环判断，导致的结果就是要不丢包严重，要不CPU占用率高，还是建以利用socket自己去实现UDP。 参考：QT中UDPSocket丢包问题_rabbitjerry的专栏-CSDN博客_qt udp丢包 1.信号槽机制访问 #include <QCoreApplication> #include <QUdpSocket> #include <QHostAddress&g
高性能UDP接收， 不丢包，win API 版本
TuringEvo专栏
07-29 1154
高性能UDP接收， 不丢包，win API 版本 非阻塞方式连接 由于采用阻塞模式，在没有数据的情况下会等待，这里我们接收立即返回，采用非阻塞模式 //设置非阻塞方式连接 unsigned long ul = 1; int ret = ioctlsocket(sock, FIONBIO, (unsigned long*)&ul); if (ret != NO_ERROR){ printf("ioctlsocket f
[MFC]UDP通信的简单实现
Lirx_Tech的专栏
07-21 1万+
1. UDP和TCP最大的区别：      1) TCP最大的特点就是面向连接、安全可靠，也就是说TCP通信必须要先建立连接，并且通信过程需要时时校验，如果数据有误需要重发；      2) UDP最大的特点就是面向无连接，不可靠，也就是说不用建立连接就直接向目标发送信息，并且通信过程中不做任何校验，如果数据丢失或者有误也不管；      3) 听上去UDP非常的无用，但其实不然，UDP最大
C++中UDP通讯详解
热门推荐
u011555996的博客
09-20 1万+
C++
Windows网络编程之UDP通信
a10534126的博客
04-28 977
实验二 UDP 通信实验 通信模型: 1 实验类型 验证型实验 2 实验目的 1. 进一步理解Winsock API 的调用方法 2. 了解UDP 协议的工作原理 3. 掌握UDP 服务端程序和客户端程序的编写流程 4. 熟悉程序的调试方法。 3 背景知识 1. Winsock 编程模型 Winsock 编程的主要模型分为流套接字编程模型和数据报套接字编程模型两类，主要区 别在于：前者提供双向的、有序的、无重复并且无记录边界的数据流服务，即采用有连接的 数据传输服务，保证数据可靠到达；后者也支持双向数据流
TCP/UDP相关面试常问
QNBZ的博客
08-02 736
tcp3次握手底层原理，大量time_wait,大量close_wait,大量fin_wait2,为何两次握手不行，4次挥手后的2msl作用，半连接队列，全连接队列，send和recv不同返回值代表的意思，epollhup和epollrdhup以及EPIPE的关系，QUIC,KCP
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值