信号驱动，超时接收

╰半夏微凉° 2022-12-14 13:34 200阅读 0赞

一、信号驱动。  
1、信号驱动原理是什么？  
就是使用了系统编程中信号的机制，首先让程序安装SIGIO的信号处理函数，通过监听文件描述符是否产生了SIGIO信号，我们就知道文件描述符有没有数据到达。如果有数据到达(小明这个客人来了)，则系统就会产生了SIGIO信号(门铃响了)，我们只需要在信号处理函数读取数据即可。

模型：

void fun(int sig)  
\{  
//读取sockfd的数据即可。  
\}

signal(SIGIO,fun); -> 只要将来收到SIGIO这个信号，就执行fun这个函数  
sockfd -> 只要有数据到达sockfd，就会产生一个SIGIO的信号

2、 信号驱动特点以及步骤。  
特点： 适用于UDP协议，不适用于TCP协议。

步骤一： 由于不知道数据什么时候会到达，所以需要提前捕捉SIGIO信号。 -> signal()  
步骤二： 设置套接字的属主，其实就是告诉这个套接字对应的进程ID是谁。 -> fcntl()  
步骤三： 给套接字添加信号触发模式。 -> fcntl()

1）如何设置属主？ -> fcntl() -> man 2 fcntl

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

int fcntl(int fd, int cmd, ... /\* arg \*/ );  
  
fd: 文件描述符  
cmd: F\_GETFL (void) -> 获取文件属性  
F\_SETFL (int) -> 设置文件属性  
F\_SETOWN (int) -> 设置属性 -> 最后一个参数要填，填进程ID号，一般都是getpid()。

返回值：  
成功：文件描述符所有者  
失败：-1

例如： fcntl(sockfd,F\_SETOWN,getpid()); -> 让sockfd与进程ID绑定在一起。

2）如何添加信号触发模式？ -> fcntl() -> man 2 fcntl

int state;  
state = fcntl(sockfd,F\_GETFL);  
state |= O\_ASYNC;  
fcntl(sockfd,F\_SETFL,state);

例题1： 使用信号驱动IO模型写一个UDP协议服务器，实现监听多个客户端给我发送过来的消息。

\#include "head.h"

int sockfd;  
struct sockaddr\_in cliaddr;  
socklen\_t len = sizeof(cliaddr);

void func(int sig)  
\{  
//将sockfd中的数据读取出来。  
char buf\[100\];  
  
bzero(&cliaddr,sizeof(cliaddr));  
bzero(buf,sizeof(buf));  
recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr \*)&cliaddr,&len);  
  
printf("from cli:%s",buf);  
  
\}

int main(int argc,char \*argv\[\]) // ./server 50001  
\{  
//1. 创建UDP套接字  
sockfd = socket(AF\_INET,SOCK\_DGRAM,0);  
  
//2. 绑定IP地址  
struct sockaddr\_in srvaddr;  
bzero(&srvaddr,sizeof(srvaddr));  
  
srvaddr.sin\_family = AF\_INET;  
srvaddr.sin\_port = htons(atoi(argv\[1\]));  
srvaddr.sin\_addr.s\_addr = htonl(INADDR\_ANY);  
  
bind(sockfd,(struct sockaddr \*)&srvaddr,len);  
  
//3. 捕捉信号。  
signal(SIGIO,func);  
  
//4. 设置属主  
fcntl(sockfd,F\_SETOWN,getpid());  
  
//5. 添加信号触发模式。  
int state;  
state = fcntl(sockfd,F\_GETFL);  
state |= O\_ASYNC;  
fcntl(sockfd,F\_SETFL,state);  
  
//6. 坐等各位给我写信就可以。  
while(1)  
pause();  
  
return 0;  
\}

二、超时接收。  
1、为什么会有超时接收？  
一般地，我们都习惯使用阻塞IO，就是有数据就读取，没有数据就会一直阻塞等待。  
因为有可能会出现一种情况，就是一直等待，都等不到结果，所以超时接收就是为了解决这个问题。

2、如何实现超时控制？ --- 方法一：使用多路复用。

select(xx,xxx,xx,xx,NULL); -> 无限等待集合中的数据。  
\-> 如果集合中的文件描述符有数据到达，则函数就会返回。  
\-> 如果集合中的文件描述符没有数据到达在，则函数就会一直阻塞。

每次select之前，都需要重置好时间。  
select(xx,xxx,xx,xx,5S); -> 只会在5S内阻塞等待，5S后就会返回。  
\-> 5S内有数据到达，则函数返回就绪的文件描述符个数。  
\-> 5S内没有数据到达，则5S内会阻塞。  
\-> 5S后，这个函数就会返回0，不会继续监听这个集合。

3、如何设置时间？  
int select(int nfds, fd\_set \*readfds, fd\_set \*writefds,fd\_set \*exceptfds, struct timeval \*timeout);

时间结构体：  
struct timeval \{  
long tv\_sec; //秒  
long tv\_usec; //微秒  
\};

例如：设置5S  
struct timeval v;  
v.tv\_sec = 5;  
v.tv\_usec = 0;

select(xx,xx,xx,xx,&v);

例题2： 写一个TCP协议服务器，使用select函数去监听客户端的消息，如果客户端在5S内没有数据到达，则打印一句"timeout"，如果有数据，就打印客户端所说的话。

\#include "head.h"

void \*func(void \*arg)  
\{  
int i;  
for(i=0;i<1000;i++)  
\{  
printf("i = %d\\n",i);  
sleep(1);  
\}  
\}

int main(int argc,char \*argv\[\]) // ./rose 50000  
\{  
//0. 创建一个线程，用于计算事件。  
pthread\_t tid;  
pthread\_create(&tid,NULL,func,NULL);  
  
//1. 创建TCP套接字  
int sockfd;  
sockfd = socket(AF\_INET,SOCK\_STREAM,0);  
printf("sockfd = %d\\n",sockfd);  
  
//2. 绑定IP地址，端口号  
struct sockaddr\_in srvaddr;  
socklen\_t len = sizeof(srvaddr);  
bzero(&srvaddr,len);  
  
srvaddr.sin\_family = AF\_INET; //地址族  
srvaddr.sin\_port = htons(atoi(argv\[1\])); //端口号  
srvaddr.sin\_addr.s\_addr = htonl(INADDR\_ANY); //IP地址 /usr/include/linux/in.h  
  
bind(sockfd,(struct sockaddr \*)&srvaddr,len);  
  
//3. 设置监听套接字  
//调用listen之前： sockfd -> 待连接的套接字  
listen(sockfd,5);  
//调用listen之后： sockfd -> 监听套接字  
  
//4. 等待客户端的连接  
struct sockaddr\_in cliaddr;  
int connfd;  
  
connfd = accept(sockfd,(struct sockaddr \*)&cliaddr,&len);  
if(connfd >= 0)  
\{  
printf("connfd = %d\\n",connfd);  
printf("new connection:%s\\n",inet\_ntoa(cliaddr.sin\_addr));  
\}  
  
//5. 使用多路复用读取套接字上数据  
fd\_set set;  
struct timeval v;  
int ret;  
char buf\[100\];  
  
while(1)  
\{  
FD\_ZERO(&set);  
FD\_SET(connfd,&set);  
v.tv\_sec = 5;  
v.tv\_usec = 0;  
  
ret = select(connfd+1,&set,NULL,NULL,&v);  
if(ret == -1)  
\{  
printf("select error!\\n");  
\}  
  
if(ret == 0)  
\{  
printf("timeout!\\n");  
\}  
  
if(ret > 0)  
\{  
bzero(buf,sizeof(buf));  
recv(connfd,buf,sizeof(buf),0);  
printf("from jack:%s",buf);  
  
if(strncmp(buf,"fenshou",7) == 0)  
\{  
break;  
\}  
\}  
\}  
  
  
//5. 阻塞读取套接字上的数据  
/\*  
char buf\[100\];  
while(1)  
\{  
bzero(buf,sizeof(buf));  
recv(connfd,buf,sizeof(buf),0);  
printf("from jack:%s",buf);  
  
if(strncmp(buf,"fenshou",7) == 0)  
\{  
break;  
\}  
\}  
\*/  
  
//6. 回收TCP套接字的资源  
close(sockfd);  
close(connfd);  
  
return 0;  
\}

练习3：修改test2/，如果在10S内，没有数据到，则打印timeout。

4、 如何实现超时接收？ -- 方法二： 设置套接字的属性为超时接收。  
1）机制如何？  
如果不给套接字设置属性，那么读取套接字上的数据时就会无限等待 -> 一直阻塞。  
如果设置超时接收属性给套接字，那么读取套接字数据时，就会有时间的限制。 -> 前一段时间阻塞，时间过了就会返回。

2）操作步骤？  
阻塞情况：  
connfd = accept(sockfd); -> 一直阻塞。  
recv(connfd); -> 一直阻塞等待数据的到达。

connfd = accept(sockfd); -> 一直阻塞。  
设置超时接收属性给connfd  
recv(connfd); -> 在规定时间内，就会阻塞读取，超过了时间，这个recv函数就会返回失败。

3）如何设置超时接收属性给套接字？ -> setsockopt() -> man 2 setsockopt  
  
\#include <sys/types.h> /\* See NOTES \*/  
\#include <sys/socket.h>  
  
int setsockopt(int sockfd, int level, int optname,const void \*optval, socklen\_t optlen);

sockfd：套接字  
level： 优先级  
SOL\_SOCKET:套接字  
IPPROTO\_IP：IP优先级  
IPPRO\_TCP：TCP优先级  
optname：选项名字  
optval： 值，使能为1，不使能为0  
optlen： 值类型大小

返回值：  
成功：0  
失败：-1

例子：  
struct timeval v;  
v.tv\_sec = 5;  
v.tv\_usec = 0;

setsockopt(connfd,SOL\_SOCKET,SO\_RCVTIMEO,&v,sizeof(v));

接下来，再去读取connfd的数据，前5S就会阻塞，过了5S就会返回失败了。

练习4： 写一个TCP服务器，使用recv函数接收客户端的消息，如果服务器在5S内，没有数据到达，就打印timeout。

\#include "head.h"

void \*func(void \*arg)  
\{  
int i;  
for(i=0;i<1000;i++)  
\{  
printf("i = %d\\n",i);  
sleep(1);  
\}  
\}

int main(int argc,char \*argv\[\]) // ./rose 50000  
\{  
//0. 创建线程  
pthread\_t tid;  
pthread\_create(&tid,NULL,func,NULL);  
  
//1. 创建TCP套接字  
int sockfd;  
sockfd = socket(AF\_INET,SOCK\_STREAM,0);  
printf("sockfd = %d\\n",sockfd);  
  
//2. 绑定IP地址，端口号  
struct sockaddr\_in srvaddr;  
socklen\_t len = sizeof(srvaddr);  
bzero(&srvaddr,len);  
  
srvaddr.sin\_family = AF\_INET; //地址族  
srvaddr.sin\_port = htons(atoi(argv\[1\])); //端口号  
srvaddr.sin\_addr.s\_addr = htonl(INADDR\_ANY); //IP地址 /usr/include/linux/in.h  
  
bind(sockfd,(struct sockaddr \*)&srvaddr,len);  
  
//3. 设置监听套接字  
//调用listen之前： sockfd -> 待连接的套接字  
listen(sockfd,5);  
//调用listen之后： sockfd -> 监听套接字  
  
//4. 等待客户端的连接  
struct sockaddr\_in cliaddr;  
int connfd;  
  
connfd = accept(sockfd,(struct sockaddr \*)&cliaddr,&len);  
if(connfd >= 0)  
\{  
printf("connfd = %d\\n",connfd);  
printf("new connection:%s\\n",inet\_ntoa(cliaddr.sin\_addr));  
\}  
  
//5. 设置超时属性给connfd。  
struct timeval v;  
v.tv\_sec = 5;  
v.tv\_usec = 0;  
  
setsockopt(connfd,SOL\_SOCKET,SO\_RCVTIMEO,&v,sizeof(v));  
  
//6. 不断读取connfd的内容。  
char buf\[100\] = \{0\};  
while(1)  
\{  
bzero(buf,sizeof(buf));  
if(recv(connfd,buf,sizeof(buf),0) >= 0) //有数据到达  
\{  
printf("from client:%s",buf);  
\}  
else\{ //返回失败，说明5S内都没有数据到达，即超时。  
printf("timeout!\\n");  
\}  
  
if(strncmp(buf,"quit",4) == 0)  
\{  
break;  
\}  
\}  
  
close(connfd);  
close(sockfd);  
return 0;  
\}