恳求指教！！！信号用于事件通知中遇到的问题

nervfzb

我希望有一个进程使用pause挂起，然后这个进程注册了一个信号A，如果我向这个进程发送信号，那么pause的阻塞就解除然后运行代码，运行完后又pause挂起。
例如这段代码在运行的时候，进程就可以不断的响应信号并执行pause后面的代码：

1. #include <stdio.h>
   
2. #include <signal.h>
   
3. #include <unistd.h>
   
4. 
   
5. #define        UNHAPPEND 0
   
6. #define        HAPPEND        1
   
7. 
   
8. int flag_happen;
   
9. 
   
10. void handler_sigint(int signal)
    
11. {
    
12.         flag_happen = HAPPEND;
    
13. }
    
14. 
    
15. int main()
    
16. {
    
17.         if(signal(SIGINT,handler_sigint) == SIG_ERR)
    
18.         {
    
19.                 perror("signal");
    
20.                 //exit(1);
    
21.                 return -1;
    
22.         }
    
23.         while(1)
    
24.         {
    
25.                 pause();
    
26.                 printf("after event happend\n");
    
27.         }
    
28. 
    
29.         return 0;
    
30. }
    

复制代码

现在有个想法，在进程中开启一个线程，然后pause阻塞，在线程中发送信号给这个进程后，解除pause阻塞并运行后面的代码。可惜没有达到预期目的。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <sys/types.h>
   
5. #include <setjmp.h>
   
6. #include <signal.h>
   
7. #include <pthread.h>
   
8. 
   
9. /**
   
10. * 线程函数
    
11. */
    
12. int * sinal_send_pthread(void *arg)
    
13. {
    
14.         //每隔一段时间发送一个信号
    
15.         while(1)
    
16.         {
    
17.                 sleep(1);
    
18.                 raise(SIGRTMIN+15);
    
19.                 printf("send signal\n");
    
20.         }
    
21. }
    
22. 
    
23. /**
    
24. * 信号函数
    
25. */
    
26. void signal_handler(int signal,siginfo_t *siginfo,void *pvoid)
    
27. {
    
28.         printf("recv signal\n");
    
29. }
    
30. 
    
31. int main()
    
32. {
    
33.         //注册一个信号
    
34.         signal(SIGRTMIN+15,signal_handler);
    
35. 
    
36.         //创建一个线程
    
37.         pthread_t sig_send;
    
38.        
    
39.         if(0 != pthread_create(&sig_send,NULL,(void *)sinal_send_pthread,
    
40.                                                         NULL))
    
41.         {
    
42.                 perror("pthread create");
    
43.                 exit(1);
    
44.         }
    
45.         while(1)
    
46.         {
    
47.                 pause();//这里等待阻塞信号
    
48.                 printf("pause end\n");
    
49.         }
    
50.         return 0;
    
51. }

复制代码

这个代码的运行结果是：
recv signal
send signal
recv signal
send signal
……
请教 一下，这种功能该如何实现？感谢！！！

nervfzb

又想到尝试使用
sigsetjmp/siglongjmp函数来实现跳转的方式执行代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <sys/types.h>
   
5. #include <setjmp.h>
   
6. #include <signal.h>
   
7. #include <pthread.h>
   
8. 
   
9. /**
   
10. * 线程函数
    
11. */
    
12. int * sinal_send_pthread(void *arg)
    
13. {
    
14.         //每隔一段时间发送一个信号
    
15.         union sigval value;
    
16.         while(1)
    
17.         {
    
18.                 sleep(1);
    
19.                 value.sival_ptr = arg;//这里发送信号的时候带上数据jmp_buf env
    
20.                 printf("send signal\n");
    
21. 
    
22.                 if(sigqueue(getpid(),SIGRTMIN+15,value) < 0)
    
23.                 {
    
24.                         perror("sigqueue");
    
25.                         exit(1);
    
26.                 }
    
27.         }
    
28. }
    
29. 
    
30. /**
    
31. * 信号函数
    
32. */
    
33. void signal_handler(int signal,siginfo_t *siginfo,void *pvoid)
    
34. {
    
35.         printf("recv signal\n");
    
36.         siglongjmp(*((jmp_buf *)(siginfo->si_ptr)),1);//跳转到sigsetjmp这个地方
    
37. }
    
38. 
    
39. int main()
    
40. {
    
41.         //创建一个跳转变量
    
42.         jmp_buf env;
    
43. 
    
44.         struct sigaction act;
    
45. 
    
46.         //创建一个线程
    
47.         pthread_t sig_send;
    
48. 
    
49.         if(0 != pthread_create(&sig_send,NULL,(void *)sinal_send_pthread,
    
50.                                                         &env))
    
51.         {
    
52.                 perror("pthread create");
    
53.                 exit(1);
    
54.         }
    
55. 
    
56.         switch(sigsetjmp(env,1))
    
57.         {
    
58.         case 0:
    
59.                 break;
    
60.         case 1:
    
61.                 printf("pause end xxx\n");
    
62.                 break;
    
63.         default:
    
64.                 break;
    
65.         }
    
66.         //调整信号使用3参数信号处理函数
    
67.         act.sa_sigaction = signal_handler;
    
68.         act.sa_flags = SA_SIGINFO;
    
69.         sigaction(SIGRTMIN+15,&act,NULL);
    
70. 
    
71.         while(1)
    
72.         {
    
73.                 pause();//这里等待阻塞信号
    
74.                 printf("pause end\n");
    
75.         }
    
76.         return 0;
    
77. }

复制代码

结果是这样的
send signal
recv signal
pause end xxx
然后就没有一直这样了。并没有运行pause函数后面的打印语句。
恳求指教，不知道这个该如何实现了！！！

nervfzb

恳求指教！！这个我不是很清楚linux如何阻塞进程然后等待各类信号的响应，如果是进程向进程发送信息，应该是可以正常的响应信号，但是同一个进程下的线程发送信号给本进程似乎就不行了，关键点在于 进程似乎在pause函数里面然后跳不出来了。

nervfzb

如果是两个进程发信号的话，接收信号的进程不仅可以接收到注册的信号并运行绑定的信号处理函数，还能解除pause阻塞，如果一个进程创建一个线程，并使用这个线程给创建自己的进程发送信号的话，进程能接收到信号并运行信号处理函数，但是pause依然阻塞。

MMMIX

int * sinal_send_pthread(void *arg)
{
        //每隔一段时间发送一个信号
        while(1)
        {
                sleep(1);
                raise(SIGRTMIN+15);
                printf("send signal\n");
        }
}
nervfzb 发表于 2011-08-31 16:12

你这里的 raise() 能把信号送给主进程么？

MMMIX

现在有个想法，在进程中开启一个线程，然后pause阻塞，在线程中发送信号给这个进程后，解除pause阻塞并运行后面的代码。可惜没有达到预期目的。
nervfzb 发表于 2011-08-31 16:12

    沒有達到預期目的是因為你把 signal 發給了錯誤的 thread：

1. 
   
2. 
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <unistd.h>
   
6. #include <sys/types.h>
   
7. #include <setjmp.h>
   
8. #include <signal.h>
   
9. #include <pthread.h>
   
10. 
    
11. int * sinal_send_pthread(void *arg)
    
12. {
    
13.         while(1)
    
14.         {
    
15.                 sleep(1);
    
16.                 //raise(SIGRTMIN+15);
    
17.                 pthread_kill(*(pthread_t *)arg, SIGRTMIN+15);
    
18.                 printf("send signal\n");
    
19.         }
    
20. }
    
21. 
    
22. void signal_handler(int signal,siginfo_t *siginfo,void *pvoid)
    
23. {
    
24.         printf("recv signal\n");
    
25. }
    
26. 
    
27. int main()
    
28. {
    
29.         signal(SIGRTMIN+15,signal_handler);
    
30. 
    
31.         pthread_t main_thread, sig_send;
    
32. 
    
33.         main_thread = pthread_self();
    
34. 
    
35.         if(0 != pthread_create(&sig_send,NULL,(void *)sinal_send_pthread,
    
36.                                 &main_thread))
    
37.         {
    
38.                 perror("pthread create");
    
39.                 exit(1);
    
40.         }
    
41.         while(1)
    
42.         {
    
43.                 pause();
    
44.                 printf("pause end\n");
    
45.         }
    
46.         return 0;
    
47. }
    

复制代码

運行的結果：

1. 
   
2. 
   
3. lee@debian:/tmp$ ./a.out
   
4. send signal
   
5. recv signal
   
6. pause end
   
7. send signal
   
8. recv signal
   
9. pause end
   
10. send signal
    
11. recv signal
    
12. pause end
    
13. send signal
    
14. recv signal
    
15. pause end
    
16. send signal
    
17. recv signal
    
18. pause end
    
19. ^C
    
20. lee@debian:/tmp$
    

复制代码

nervfzb

回复 6# MMMIX


    实在太感谢了！！！！
    其实使用raise函数主要是看到这么一句：“raise函数用来给调用它的进程发送信号”。所以我就猜想在一个进程中开启线程，然后调用raise函数，这样就会向进程发送信号：实验结果就是能触发信号函数但无法解除pause阻塞（ubuntu 11.04）。
    您的代码我再好好看看，感谢！！！

MMMIX

其实使用raise函数主要是看到这么一句：“raise函数用来给调用它的进程发送信号”。所以我就猜想在一个进程中开启线程，然后调用raise函数，这样就会向进程发送信号：
nervfzb 发表于 2011-09-08 14:16

    你应该看看 raise() 的手册 raise(3)，而不是猜测它会有什么行为。它的行为在其手册中已经说的非常清楚了，根本不需要猜测。

vincentff7

回复  MMMIX


    实在太感谢了！！！！
    其实使用raise函数主要是看到这么一句：“raise函数用来 ...
nervfzb 发表于 2011-09-08 14:16

    貌似是因为linux中，每个线程都是作为独立进程来执行的。因此创建的新线程实际是另一个进程，调用raise，原有进程收不到信号。所以原有进程一直在pause状态