实现SIGIO驱动的socket编程例子（自己写的，希望能对大家有参考价值）

realtang

采用异步信号模式进行socket的编程，对于提供程序的运行效率很有好处.
该两个程序版权属于realtang，您可以在遵循GPL授权的许可下任意使用。
接收端：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <fcntl.h>
   
6. #include <errno.h>
   
7. #include <netinet/in.h>                 /*socket address struct*/
   
8. #include <arpa/inet.h>                        /*host to network convertion*/
   
9. #include <sys/socket.h>
   
10. #include <sys/types.h>
    
11. #include <signal.h>
    
12. #include <sys/ioctl.h>
    
13. #define MAX_TRANSPORT_LENTH 512
    
14. 
    
15. static int g_var = 0;
    
16. static int g_skt = 0;
    
17. void sig_handler(int signum)
    
18. {
    
19.         char  buf[MAX_TRANSPORT_LENTH+1] = "";
    
20.         int len = 0;
    
21.         len = read(g_skt,buf,MAX_TRANSPORT_LENTH);
    
22.         if (len<0)
    
23.         {
    
24.                 perror("Read socket failed");
    
25.                 exit(-1);       
    
26.         }
    
27.         else
    
28.         {
    
29.                 printf("In SIGIO handler,got msg:%s\n",buf);
    
30.         }       
    
31. }
    
32. 
    
33. int main()
    
34. {
    
35.         struct sockaddr_in addr;
    
36.         memset(&addr,0,sizeof(addr));
    
37.         addr.sin_family =  AF_INET;
    
38.         addr.sin_addr.s_addr = INADDR_ANY;
    
39.         addr.sin_port = htons(50001);
    
40.        
    
41.         signal(SIGIO,sig_handler);
    
42.        
    
43.         g_skt = socket(AF_INET,SOCK_DGRAM,0);
    
44.         if(g_skt == -1)
    
45.         {
    
46.                 perror("Create socket failed");
    
47.                 exit(-1);
    
48.         }
    
49.        
    
50.         int len = sizeof(addr);
    
51.         int ret = 0;
    
52. 
    
53.         int on = 1;
    
54.     ret = fcntl(g_skt, F_SETOWN, getpid());//Set process or process group ID to receive SIGIO signals
    
55.         if(-1 == ret)
    
56.         {
    
57.                 perror("Fcntl F_SETOWN failed");
    
58.                 exit(-1);               
    
59.         }
    
60.     ret = ioctl(g_skt, FIOASYNC, &on);
    
61.         if(-1 == ret)   
    
62.         {
    
63.                 perror("Fcntl FIOASYNC failed");
    
64.                 exit(-1);               
    
65.         }   
    
66.     ret = ioctl(g_skt, FIONBIO, &on);
    
67.         if(-1 == ret)   
    
68.         {
    
69.                 perror("ioctl FIONBIO failed");
    
70.                 exit(-1);               
    
71.         }
    
72. 
    
73.         ret = bind(g_skt,(struct sockaddr *)&addr,sizeof(addr));
    
74.         if(-1 == ret)
    
75.         {
    
76.                 perror("Bind socket failed");
    
77.                 exit(-1);
    
78.         }                       
    
79.         while(1)
    
80.         {
    
81.                 printf("I am running\n");
    
82.                 sleep(2);               
    
83.         }       
    
84.         close(g_skt);       
    
85. }
    
86. 
    

复制代码

发送端：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <fcntl.h>
   
6. #include <errno.h>
   
7. #include <netinet/in.h>                 /*socket address struct*/
   
8. #include <arpa/inet.h>                        /*host to network convertion*/
   
9. #include <sys/socket.h>
   
10. #include <signal.h>
    
11. #define MAX_TRANSPORT_LENTH 512
    
12. 
    
13. int main()
    
14. {
    
15.         struct sockaddr_in addr;
    
16.         memset(&addr,0,sizeof(addr));
    
17.         addr.sin_family =  AF_INET;
    
18.         addr.sin_addr.s_addr = inet_addr("192.168.1.106");
    
19.         addr.sin_port = htons(50001);
    
20.        
    
21.         int sock;
    
22.         sock = socket(AF_INET,SOCK_DGRAM,0);
    
23.         if(sock == -1)
    
24.         {
    
25.                 perror("Create socket failed");
    
26.                 exit(-1);
    
27.         }
    
28.        
    
29.         int ret;
    
30.         ret = connect(sock,(struct sockaddr *)&addr,sizeof(addr));
    
31.         if(ret == -1)
    
32.         {
    
33.                 perror("Connect socket failed");
    
34.                 exit(-1);               
    
35.         }               
    
36.         while(1)
    
37.         {
    
38.                 printf("Will send messge to server\n");
    
39.                 write(sock,"Some unknown infomation\n",MAX_TRANSPORT_LENTH);
    
40.                 sleep(1);
    
41.         }
    
42.        
    
43. }
    
44. 
    

复制代码

realtang

上述的程序采用了UDP而不采用TCP是因为TCP的通讯中产生SIGIO信号的情况实在太复杂了。不如UDP来得纯粹，只在接收到信息和检测到异常时才触发SIGIO信号。

rickxbx

哦，这个程序的意思是将服务器端的主线程从等待数据中解放出来，而由信号处理函数来处理该端口收到的数据
right？

realtang

Post by rickxbx
哦，这个程序的意思是将服务器端的主线程从等待数据中解放出来，而由信号处理函数来处理该端口收到的数据
right？

可以这么说，但不是很全面。这个程序的主要作用是对于某些应用，他基本上埋头干自己的事，对于外界的信息需要知道的很少，但偶尔也会收收发发信息来控制自己运行的轨迹的时候，就可以采用异步信号的方式。因为这样做效率比较高。
如果是采用单线程，非阻塞方式，会浪费很多cpu循环。
如果是采用多线程，会增加资源的利用以及上下文切换的开销。况且，linux对于线程的调度上，对于某些实时线程还存在一些问题。

rickxbx

Post by realtang
但偶尔也会收收发发信息

如何做到？

daemeon

modified version

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <fcntl.h>
   
6. #include <errno.h>
   
7. #include <string.h>
   
8. #include <signal.h>
   
9. #include <netinet/in.h>
   
10. #include <arpa/inet.h>
    
11. #include <sys/socket.h>
    
12. #include <sys/types.h>
    
13. #include <sys/ioctl.h>
    
14. #define MAX_LENTH 1500
    
15. 
    
16. static int nqueue = 0;
    
17. void sigio_handler(int signum)
    
18. {
    
19.         if (signum = SIGIO)
    
20.                 nqueue++;
    
21.         return;
    
22. }
    
23. 
    
24. static recv_buf[MAX_LENTH];
    
25. int main(int argc, char *argv[])
    
26. {
    
27.         int sockfd, on = 1;
    
28.         struct sigaction action;
    
29.         sigset_t newmask, oldmask;
    
30.         struct sockaddr_in addr;
    
31. 
    
32.         memset(&addr, 0, sizeof(addr));
    
33.         addr.sin_family =  AF_INET;
    
34.         addr.sin_addr.s_addr = INADDR_ANY;
    
35.         addr.sin_port = htons(50001);
    
36.         if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
    
37.                 perror("Create socket failed");
    
38.                 exit(-1);
    
39.         }
    
40.         if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
    
41.                 perror("Bind socket failed");
    
42.                 exit(-1);
    
43.         }
    
44. 
    
45.         memset(&action, 0, sizeof(action));
    
46.         action.sa_handler = sigio_handler;
    
47.         action.sa_flags = 0;
    
48.         sigaction(SIGIO, &action, NULL);
    
49.         if (fcntl(sockfd, F_SETOWN, getpid()) == -1) {
    
50.                 perror("Fcntl F_SETOWN failed");
    
51.                 exit(-1);               
    
52.         }
    
53.         if (ioctl(sockfd, FIOASYNC, &on) == -1) {
    
54.                 perror("Ioctl FIOASYNC failed");
    
55.                 exit(-1);               
    
56.         }
    
57. 
    
58.         sigemptyset(&oldmask);
    
59.         sigemptyset(&newmask);
    
60.         sigaddset(&newmask, SIGIO);
    
61.         while (1) {
    
62.                 int len;
    
63.                 sigprocmask(SIG_BLOCK, &newmask, &oldmask);
    
64.                 while (nqueue == 0)
    
65.                         sigsuspend(&oldmask);
    
66.                 len = recv(sockfd, recv_buf, MAX_LENTH, MSG_DONTWAIT);
    
67.                 if (len == -1 && errno == EAGAIN)
    
68.                         nqueue = 0;
    
69.                 sigprocmask(SIG_SETMASK, &oldmask, NULL);
    
70.                 if (len >= 0)
    
71.                         printf("recv %d byte(s)\n", len);
    
72. 
    
73.         }
    
74. }
    

复制代码

realtang

多谢daemon兄的补充，将整个程序改成信号驱动的形式，效率提高很多啊。并且在recv的操作中禁止了SIGIO信号，更加的让程序稳定和安全。