有关pthread_join()的问题

ratcj

请问一下，如果pthread_join()函数等待的那个线程异常终止了或者说突然core掉了，那么pthread_join()能够返回吗？

有没有一种方法能够检查一个线程的状态，当这个线程终止时（不管哪种形式的终止，正常/异常），能够重新把这个线程拉起来？

现在我想的方法是再另外起一个监视线程B调用pthread_join()函数等待被监视线程A，如果被监视线程A突然挂掉了，那么
pthread_join()函数会返回，这时，监视线程B重新调用pthread_create()重新创建一个线程C，这个线程C调用与被监视线程
A相同的线程处理函数，来达到继续处理线程A需要处理的任务的目的。

写了一段测试代码，当线程A正常终止时，上面的方法是可行的；现在的问题就是，如果线程A core dump，那上面那个方法还能生效吗？

P.S. 线程A的处理函数会有一个很长的处理逻辑或者无限循环处理某些任务。

测试代码如下：

1. 
   
2. #include <stdio.h>
   
3. #include <pthread.h>
   
4. 
   
5. static pthread_t tid[2];
   
6. 
   
7. void test1()
   
8. {
   
9.        printf("thread1 continue, tid[%d]\n", pthread_self());
   
10.        sleep(5);
    
11. }
    
12. 
    
13. void test2()
    
14. {
    
15.        while(1) {
    
16.                pthread_join(tid[0], NULL);
    
17.                printf("thread2 continue, tid[%d]\n", pthread_self());
    
18. 
    
19.                pthread_create(&tid[0], NULL, (void *(*)(void
    
20. *))test1, NULL);
    
21. 
    
22.        }
    
23. }
    
24. 
    
25. int main()
    
26. {
    
27.        int ret;
    
28. 
    
29.        pthread_create(&tid[0], NULL, (void *(*)(void *))test1, NULL);
    
30.        pthread_create(&tid[1], NULL, (void *(*)(void *))test2, NULL);
    
31. 
    
32.        pthread_join(tid[1], NULL);
    
33.        return 0;
    
34. }
    

复制代码

ratcj

请问一下，如果pthread_join()函数等待的那个线程异常终止了或者说突然core掉了，那么pthread_join()能够返回吗？

有没有一种方法能够检查一个线程的状态，当这个线程终止时（不管哪种形式的终止，正常/异常），能够重新把这个线程拉起来？

现在我想的方法是再另外起一个监视线程B调用pthread_join()函数等待被监视线程A，如果被监视线程A突然挂掉了，那么
pthread_join()函数会返回，这时，监视线程B重新调用pthread_create()重新创建一个线程C，这个线程C调用与被监视线程
A相同的线程处理函数，来达到继续处理线程A需要处理的任务的目的。

写了一段测试代码，当线程A正常终止时，上面的方法是可行的；现在的问题就是，如果线程A core dump，那上面那个方法还能生效吗？

P.S. 线程A的处理函数会有一个很长的处理逻辑或者无限循环处理某些任务。

测试代码如下：

1. 
   
2. #include <stdio.h>
   
3. #include <pthread.h>
   
4. 
   
5. static pthread_t tid[2];
   
6. 
   
7. void test1()
   
8. {
   
9.        printf("thread1 continue, tid[%d]\n", pthread_self());
   
10.        sleep(5);
    
11. }
    
12. 
    
13. void test2()
    
14. {
    
15.        while(1) {
    
16.                pthread_join(tid[0], NULL);
    
17.                printf("thread2 continue, tid[%d]\n", pthread_self());
    
18. 
    
19.                pthread_create(&tid[0], NULL, (void *(*)(void*))test1, NULL);
    
20. 
    
21.        }
    
22. }
    
23. 
    
24. int main()
    
25. {
    
26.        int ret;
    
27. 
    
28.        pthread_create(&tid[0], NULL, (void *(*)(void *))test1, NULL);
    
29.        pthread_create(&tid[1], NULL, (void *(*)(void *))test2, NULL);
    
30. 
    
31.        pthread_join(tid[1], NULL);
    
32.        return 0;
    
33. }
    

复制代码

realtang

真要core dump，那整个进程都终止了。

ratcj

Post by realtang;1787277
真要core dump，那整个进程都终止了。

可能我说的不清楚，主要是处理线程意外挂起的现象，并且在多线程中，如果只是进程中其中一个线程core了，整个进程是不会终止的。

ratcj

解决了，上面的方法可以解决被监视线程终止的情况，但是不能解决线程被意外挂起的情况。

利用自定义信号和alarm就可解决挂起问题
解决方法是装载两个信号处理函数并设定alarm，一个处理alarm超时时，利用上面的方法重新启动一个线程C处理线程A的任务，并重新设定alarm；一个处理自定义信号，比如SIGUSR1，方法是在被监视线程A的处理函数中利用raise()函数定期发送SIGUSR1信号，该信号处理函数当捕捉到这个信号时就重设alarm值，这样新的值会代替久的值，那么时钟就不会超时，如果一段时间后没有收到这个信号，则被监视线程A就可能被挂起了，于是会执行处理alarm超时的处理函数。
到此，两个方法同时使用就可监视线程A，当A意外终止或被挂起的时候可以将它拉起。

P.S. 这里的监视线程A的处理函数要循环处理某些任务，被认为是将会一直运行的线程，所以任何情况的终止和挂起都是不被允许的。

测试代码如下：

1. 
   
2. #include <stdio.h>
   
3. #include <pthread.h>
   
4. #include <signal.h>
   
5. #include <time.h>
   
6. 
   
7. #define CHECK_THREAD_TIME 60
   
8. 
   
9. static pthread_t tid[2];
   
10. 
    
11. static void test1()
    
12. {
    
13.         while(1) {
    
14.                 printf("thread1 continue, tid[%d]\n", pthread_self());
    
15.                 raise(SIGUSR1);
    
16.                 sleep(5);
    
17.         }
    
18. }
    
19. 
    
20. static void test2()
    
21. {
    
22.         while(1) {
    
23.                 pthread_join(tid[0], NULL);
    
24.                 printf("thread2 continue, tid[%d]\n", pthread_self());
    
25. 
    
26.                 pthread_create(&tid[0], NULL, (void *(*)(void *))test1, NULL);
    
27. 
    
28.         }
    
29. }
    
30. 
    
31. static void
    
32. overtime_handler(int signo)
    
33. {
    
34.         time_t tm;
    
35. 
    
36.         //time alarm
    
37.         printf("abnormal: thread has been hanged, time[%s], restart...\n", ctime(&tm));
    
38. 
    
39.         pthread_create(&tid[0], NULL, (void *(*)(void *))test1, NULL);
    
40.         alarm(CHECK_THREAD_TIME);
    
41. }
    
42. 
    
43. static void
    
44. resetalarm_handler(int signo)
    
45. {
    
46.         int ret;
    
47. 
    
48.         ret = alarm(CHECK_THREAD_TIME);
    
49.         printf("oh yeah! thread is still running, after [%d] seconds alarm will overtime\n", ret);
    
50. }
    
51. 
    
52. int main()
    
53. {
    
54.         int ret;
    
55. 
    
56.         struct sigaction sa;
    
57.         memset(&sa, 0x0, sizeof(sa));
    
58.         sa.sa_handler = overtime_handler;
    
59.         sigaction(SIGALRM, &sa, NULL);
    
60. 
    
61.         sa.sa_handler = resetalarm_handler;
    
62.         sigaction(SIGUSR1, &sa, NULL);
    
63. 
    
64.         alarm(CHECK_THREAD_TIME);
    
65. 
    
66.         pthread_create(&tid[0], NULL, (void *(*)(void *))test1, NULL);
    
67.         pthread_create(&tid[1], NULL, (void *(*)(void *))test2, NULL);
    
68. 
    
69.         pthread_join(tid[1], NULL);
    
70.         return 0;
    
71. }
    

复制代码

realtang

其实检测线程是否挂起也很容易，就跟heart beat的原理一样，用另外一个线程或进程不断的跟它通信（socket，信号，IPC消息队列），一旦没有响应，就说明它挂了。

ratcj

Post by realtang;1787437
其实检测线程是否挂起也很容易，就跟heart beat的原理一样，用另外一个线程或进程不断的跟它通信（socket，信号，IPC消息队列），一旦没有响应，就说明它挂了。

正解，我就是使用的这种方法，呵呵。

jetking

占位贴，以后查起来方便点:sorry