Socket编程实践(8) --套接字IO超时设置方法

引:超时设置3种方案

1. alarm超时设置方法

[cpp]  view plain copy

1. //代码实现: 这种方式较少用  
2. void sigHandlerForSigAlrm(int signo)  
3. {  
4.     return ;  
5. }  
6.   
7. signal(SIGALRM, sigHandlerForSigAlrm);  
8. alarm(5);  
9. int ret = read(sockfd, buf, sizeof(buf));  
10. if (ret == -1 && errno == EINTR)  
11. {  
12.     // 超时被时钟打断  
13.     errno = ETIMEDOUT;  
14. }  
15. else if (ret >= 0)  
16. {  
17.     // 正常返回(没有超时), 则将闹钟关闭  
18.     alarm(0);  
19. }  

2. 套接字选项: SO_SNDTIMEO, SO_RCVTIMEO

调用setsockopt设置读/写超时时间

[cpp]  view plain copy

1. //示例: read超时  
2. int seconds = 5;  
3. if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &seconds, sizeof(seconds)) == -1)  
4.     err_exit("setsockopt error");  
5. int ret = read(sockfd, buf, sizeof(buf));  
6. if (ret == -1 && errno == EWOULDBLOCK)  
7. {  
8.     // 超时,被时钟打断  
9.     errno = ETIMEDOUT;  
10. }  

3. select方式[重点]

 

_timeout函数封装

1. read_timeout封装

[cpp]  view plain copy

1. /** 
2.  *read_timeout - 读超时检测函数, 不包含读操作 
3.  *@fd: 文件描述符 
4.  *@waitSec: 等待超时秒数, 0表示不检测超时 
5.  *成功(未超时)返回0, 失败返回-1, 超时返回-1 并且 errno = ETIMEDOUT 
6. **/  
7. int read_timeout(int fd, long waitSec)  
8. {  
9.     int returnValue = 0;  
10.     if (waitSec > 0)  
11.     {  
12.         fd_set readSet;  
13.         FD_ZERO(&readSet);  
14.         FD_SET(fd,&readSet);    //添加  
15.   
16.         struct timeval waitTime;  
17.         waitTime.tv_sec = waitSec;  
18.         waitTime.tv_usec = 0;       //将微秒设置为0(不进行设置),如果设置了,时间会更加精确  
19.         do  
20.         {  
21.             returnValue = select(fd+1,&readSet,NULL,NULL,&waitTime);  
22.         }  
23.         while(returnValue < 0 && errno == EINTR);   //等待被(信号)打断的情况, 重启select  
24.   
25.         if (returnValue == 0)   //在waitTime时间段中一个事件也没到达  
26.         {  
27.             returnValue = -1;   //返回-1  
28.             errno = ETIMEDOUT;  
29.         }  
30.         else if (returnValue == 1)  //在waitTime时间段中有事件产生  
31.             returnValue = 0;    //返回0,表示成功  
32.         // 如果(returnValue == -1) 并且 (errno != EINTR), 则直接返回-1(returnValue)  
33.     }  
34.   
35.     return returnValue;  
36. }  

2. write_timeout封装

[cpp]  view plain copy

1. /** 
2.  *write_timeout - 写超时检测函数, 不包含写操作 
3.  *@fd: 文件描述符 
4.  *@waitSec: 等待超时秒数, 0表示不检测超时 
5.  *成功(未超时)返回0, 失败返回-1, 超时返回-1 并且 errno = ETIMEDOUT 
6. **/  
7. int write_timeout(int fd, long waitSec)  
8. {  
9.     int returnValue = 0;  
10.     if (waitSec > 0)  
11.     {  
12.         fd_set writeSet;  
13.         FD_ZERO(&writeSet);      //清零  
14.         FD_SET(fd,&writeSet);    //添加  
15.   
16.         struct timeval waitTime;  
17.         waitTime.tv_sec = waitSec;  
18.         waitTime.tv_usec = 0;  
19.         do  
20.         {  
21.             returnValue = select(fd+1,NULL,&writeSet,NULL,&waitTime);  
22.         } while(returnValue < 0 && errno == EINTR); //等待被(信号)打断的情况  
23.   
24.         if (returnValue == 0)   //在waitTime时间段中一个事件也没到达  
25.         {  
26.             returnValue = -1;   //返回-1  
27.             errno = ETIMEDOUT;  
28.         }  
29.         else if (returnValue == 1)  //在waitTime时间段中有事件产生  
30.             returnValue = 0;    //返回0,表示成功  
31.     }  
32.   
33.     return returnValue;  
34. }  

3. accept_timeout函数封装

[cpp]  view plain copy

1. /** 
2.  *accept_timeout - 带超时的accept 
3.  *@fd: 文件描述符 
4.  *@addr: 输出参数, 返回对方地址 
5.  *@waitSec: 等待超时秒数, 0表示不使用超时检测, 使用正常模式的accept 
6.  *成功(未超时)返回0, 失败返回-1, 超时返回-1 并且 errno = ETIMEDOUT 
7. **/  
8. int accept_timeout(int fd, struct sockaddr_in *addr, long waitSec)  
9. {  
10.     int returnValue = 0;  
11.     if (waitSec > 0)  
12.     {  
13.         fd_set acceptSet;  
14.         FD_ZERO(&acceptSet);  
15.         FD_SET(fd,&acceptSet);    //添加  
16.   
17.         struct timeval waitTime;  
18.         waitTime.tv_sec = waitSec;  
19.         waitTime.tv_usec = 0;  
20.         do  
21.         {  
22.             returnValue = select(fd+1,&acceptSet,NULL,NULL,&waitTime);  
23.         }  
24.         while(returnValue < 0 && errno == EINTR);  
25.   
26.         if (returnValue == 0)  //在waitTime时间段中没有事件产生  
27.         {  
28.             errno = ETIMEDOUT;  
29.             return -1;  
30.         }  
31.         else if (returnValue == -1) // error  
32.             return -1;  
33.     }  
34.   
35.     /**select正确返回: 
36.         表示有select所等待的事件发生:对等方完成了三次握手, 
37.         客户端有新的链接建立,此时再调用accept就不会阻塞了 
38.     */  
39.     socklen_t socklen = sizeof(struct sockaddr_in);  
40.     if (addr != NULL)  
41.         returnValue = accept(fd,(struct sockaddr *)addr,&socklen);  
42.     else  
43.         returnValue = accept(fd,NULL,NULL);  
44.   
45.     return returnValue;  
46. }  

4. connect_timeout函数封装

(1)我们为什么需要这个函数?

   TCP/IP在客户端连接服务器时,如果发生异常,connect(如果是在默认阻塞的情况下)返回的时间是RTT(相当于客户端阻塞了这么长的时间,客户需要等待这么长的时间,显然这样的客户端用户体验并不好(完成三次握手需要使用1.5RTT时间));会造成严重的软件质量下降.

(2)怎样实现connect_timeout?

   1)sockfd首先变成非阻塞的; 然后试着进行connect,如果网络状况良好,则立刻建立链接并返回,如果网络状况不好,则链接不会马上建立,这时需要我们的参与:调用select,设置等待时间,通过select管理者去监控sockfd,一旦能够建立链接,则马上返回,然后建立链接,这样就会大大提高我们的软件质量.

   2)需要注意:select机制监控到sockfd可写(也就是可以建立链接时),并不代表调用connect就一定能够成功(造成sockfd可写有两种情况: a.真正的链接可以建立起来了; b.建立链接的过程中发生错误,然后错误会回写错误信息,造成sockfd可写);

   通过调用getsockopt做一个容错即可(见下例)!

(3)代码实现:

[cpp]  view plain copy

1. /**设置文件描述符fd为非阻塞/阻塞模式**/  
2. bool setUnBlock(int fd, bool unBlock)  
3. {  
4.     int flags = fcntl(fd,F_GETFL);  
5.     if (flags == -1)  
6.         return false;  
7.   
8.     if (unBlock)  
9.         flags |= O_NONBLOCK;  
10.     else  
11.         flags &= ~O_NONBLOCK;  
12.   
13.     if (fcntl(fd,F_SETFL,flags) == -1)  
14.         return false;  
15.     return true;  
16. }  
17. /** 
18.  *connect_timeout - connect 
19.  *@fd: 文件描述符 
20.  *@addr: 要连接的对方地址 
21.  *@waitSec: 等待超时秒数, 0表示使用正常模式的accept 
22.  *成功(未超时)返回0, 失败返回-1, 超时返回-1 并且 errno = ETIMEDOUT 
23. **/  
24. int connect_timeout(int fd, struct sockaddr_in *addr, long waitSec)  
25. {  
26.     if (waitSec > 0)    //设置为非阻塞模式  
27.         setUnBlock(fd, true);  
28.   
29.     socklen_t addrLen = sizeof(struct sockaddr_in);  
30.     //首先尝试着进行链接  
31.     int returnValue = connect(fd,(struct sockaddr *)addr,addrLen);  
32.     //如果首次尝试失败(并且errno == EINPROGRESS表示连接正在处理当中),则需要我们的介入  
33.     if (returnValue < 0 && errno == EINPROGRESS)  
34.     {  
35.         fd_set connectSet;  
36.         FD_ZERO(&connectSet);  
37.         FD_SET(fd,&connectSet);  
38.         struct timeval waitTime;  
39.         waitTime.tv_sec = waitSec;  
40.         waitTime.tv_usec = 0;  
41.         do  
42.         {  
43.             /*一旦建立链接,则套接字可写*/  
44.             returnValue = select(fd+1, NULL, &connectSet, NULL, &waitTime);  
45.         }  
46.         while (returnValue < 0 && errno == EINTR);  
47.         if (returnValue == -1) //error  
48.             return -1;  
49.         else if (returnValue == 0)   //超时  
50.         {  
51.             returnValue = -1;  
52.             errno = ETIMEDOUT;  
53.         }  
54.         else if (returnValue == 1)  //正确返回,有一个套接字可写  
55.         {  
56.             /**由于connectSet只有一个文件描述符, 因此FD_ISSET的测试也就省了**/  
57.   
58.             /**注意:套接字可写有两种情况: 
59.                 1.连接建立成功 
60.                 2.套接字产生错误(但是此时select是正确的, 因此错误信息没有保存在errno中),需要调用getsockopt获取 
61.             */  
62.             int err;  
63.             socklen_t errLen = sizeof(err);  
64.             int sockoptret = getsockopt(fd,SOL_SOCKET,SO_ERROR,&err,&errLen);  
65.             if (sockoptret == -1)  
66.                 return -1;  
67.   
68.             // 测试err的值  
69.             if (err == 0)   //确实是链接建立成功  
70.                 returnValue = 0;  
71.             else    //连接产生了错误  
72.             {  
73.                 errno = err;  
74.                 returnValue = -1;  
75.             }  
76.         }  
77.     }  
78.     if (waitSec > 0)  
79.         setUnBlock(fd, false);  
80.     return returnValue;  
81. }  

[cpp]  view plain copy

1. /**测试:使用connect_timeout的client端完整代码(server端如前)**/  
2. int main()  
3. {  
4.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);  
5.     if (sockfd == -1)  
6.         err_exit("socket error");  
7.   
8.     struct sockaddr_in serverAddr;  
9.     serverAddr.sin_family = AF_INET;  
10.     serverAddr.sin_port = htons(8001);  
11.     serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
12.     int ret = connect_timeout(sockfd, &serverAddr, 5);  
13.     if (ret == -1 && errno == ETIMEDOUT)  
14.     {  
15.         cerr << "timeout..." << endl;  
16.         err_exit("connect_timeout error");  
17.     }  
18.     else if (ret == -1)  
19.         err_exit("connect_timeout error");  
20.   
21.     //获取并打印对端信息  
22.     struct sockaddr_in peerAddr;  
23.     socklen_t peerLen = sizeof(peerAddr);  
24.     if (getpeername(sockfd, (struct sockaddr *)&peerAddr, &peerLen) == -1)  
25.         err_exit("getpeername");  
26.     cout << "Server information: " << inet_ntoa(peerAddr.sin_addr)  
27.                  << ", " << ntohs(peerAddr.sin_port) << endl;  
28.     close(sockfd);  
29. }  

附-RTT(Round-Trip Time)介绍:

   RTT往返时延:在计算机网络中它是一个重要的性能指标，表示从发送端发送数据开始，到发送端收到来自接收端的确认（接收端收到数据后便立即发送确认），总共经历的时延。

   RTT由三个部分决定：即链路的传播时间、末端系统的处理时间以及路由器的缓存中的排队和处理时间。其中，前面两个部分的值作为一个TCP连接相对固定，路由器的缓存中的排队和处理时间会随着整个网络拥塞程度的变化而变化。所以RTT的变化在一定程度上反映了网络拥塞程度的变化。简单来说就是发送方从发送数据开始，到收到来自接受方的确认信息所经历的时间。