[结贴]pthread线程清理和资源回收问题

davelv

问题1、请求撤销线程，而且线程亦被撤销掉，但是注册的线程清理函数没有运行。

现有四个函数分别是，主函数，线程工作函数，线程监视函数，线程清理函数。
其中主函数负责建立工作线程和监视线程，而后为监视线程生产资源。

1. 
   
2. int scheduler_listen(int sock)
   
3. {
   
4.         int i ,fd ,ret;
   
5. 
   
6.         pthread_attr_init(&thread_attr);
   
7.         pthread_attr_setstacksize(&thread_attr, 1024*1024);
   
8.         pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
   
9.         //建立工作线程
   
10.         for (i=0; i<SCAN_THREAD_NUM; i++) {
    
11.                 memset(&thread_param[i], 0x00, sizeof(THREAD_PARAM));
    
12. 
    
13.                 thread_param[i].exec_time = -1;
    
14. 
    
15.                 ret = pthread_create(&(thread_param[i].scan_thread), &thread_attr, loop_scanfile, (void *)&thread_param[i]);
    
16.                 if (ret != 0) {
    
17.                         //出错
    
18.                         return -1；
    
19.                 }
    
20.         }
    
21.         //建立监视线程
    
22.         pthread_t psd;
    
23.         pthread_create(&psd, &thread_attr, status_daemon, NULL);
    
24. 
    
25.         //block self!
    
26.         while(1)
    
27.         {
    
28.                 //生产资源
    
29.         }
    
30.         puts("exit!");
    
31.         return 0;
    
32. }
    

复制代码

工作线程主要是处理主函数生产的资源。

1. 
   
2. void *loop_scanfile(void *param)
   
3. {
   
4. 
   
5.         struct cancel_param cp;
   
6.         //初始化部分
   
7.        
   
8.         //注册清理函数
   
9.         pthread_cleanup_push(thread_cleanup, &cp);
   
10.         while(1) {
    
11.                 //获取资源
    
12.                 //处理
    
13. 
    
14.         }//end while(1)
    
15.         pthread_cleanup_pop(0);
    
16. 
    
17.         return NULL;
    
18. }
    

复制代码

监视函数是为了监视工作线程是否超时，超时则请求撤销该线程，并新建一个工作线程

1. 
   
2. void *status_daemon(void *a)
   
3. {
   
4.         int i;
   
5.         time_t now;
   
6.         while(1)
   
7.         {
   
8.                 //休眠
   
9.                 sleep(5);
   
10.                
    
11.                 time(&now);
    
12.                 for(i=0; i<SCAN_THREAD_NUM; i++)
    
13.                 {        //检测超时
    
14.                         if((thread_param[i].exec_time>0) && (now-thread_param[i].exec_time >config.timeout) )
    
15.                         {
    
16.                                 printf("Scan thread timeout, restart it!\n");
    
17. 
    
18.                                 //请求撤销
    
19.                                 pthread_cancel(thread_param[i].scan_thread);
    
20.                                 //新建线程
    
21.                                 if ( pthread_create(&(thread_param[i].scan_thread), NULL, loop_scanfile, (void *)&thread_param[i]) != 0)
    
22.                                 {
    
23.                                         gate_print("%sScan thread recreate failed!",ERRSTR);
    
24.                                         exit(-1);
    
25. 
    
26.                                 }
    
27.                         }
    
28.                 }
    
29. 
    
30.         }
    
31.         return NULL;
    
32. }
    

复制代码

线程清理函数主要是负责当工作线程被撤销时，回收正在使用的资源。

1. 
   
2. void thread_cleanup(void *param)
   
3. {
   
4.         struct cancel_param *cp = (struct cancel_param*)param;
   
5.         puts("Cleaning");
   
6.         //清理资源       
   
7. }
   

复制代码

在线程超时后，没有看到清理函数输出的内容，用过pstree查看进程信息，发现线程已经取消掉，但是资源未释放内存占用越来越大。这是为什么呢？

问题2、分离属性的线程运行完毕后或者撤消后，什么样的资源是由系统自动回收的？堆分配的资源系统会自动回收么？和joinable的线程在资源处理上有什么分别？看了一些资料，写都不是很详细，麻烦诸位给点详细的资料。

jt_feelcool

借楼主的帖提个问题：

线程函数的返回值哪里获得的？

比如

void *test(void *ptr)
{
     int a=0;
     return((void*)a);
}
怎么获得a的值？pthread_create里面吗？

davelv

回复 2# jt_feelcool


    使用pthread_join()函数，但是不能用在已分离的线程上，线程默认是可以join的。

jt_feelcool

回复  jt_feelcool


    使用pthread_join()函数，但是不能用在已分离的线程上，线程默认是可以join的 ...
davelv 发表于 2010-08-17 11:42

    多谢大侠

samlumengjun

回复 1# davelv


    不管哪种属性,堆上申请的必须手工释放,但是如果是分离属性的线程,自身的栈等资源都会自行释放.

zzyong08

回复 1# davelv

1. #include <pthread.h>
   
2. #include <stdio.h>
   
3. #include <time.h>
   
4. #include <unistd.h>
   
5. 
   
6. #define N   2
   
7. 
   
8. struct thread_st {
   
9.     pthread_t ptid;
   
10.     time_t ctime;
    
11. };
    
12. 
    
13. struct thread_st pst[N];
    
14. 
    
15. void *loop(void *);
    
16. void *monitor(void *);
    
17. 
    
18. int main()
    
19. {
    
20.     size_t i;
    
21.     for (i = 0; i < N; ++i) {
    
22.         pthread_create(&pst[i].ptid, NULL, loop, pst + i);
    
23.         pst[i].ctime = time(NULL);
    
24.     }
    
25.     pthread_t ptid;
    
26.     pthread_create(&ptid, NULL, monitor, NULL);
    
27.    
    
28.     while (1) sleep(10);
    
29. 
    
30.     return 0;
    
31. }
    
32. 
    
33. void fclean(void *p)
    
34. {
    
35.     struct thread_st *pst = p;
    
36.     printf("%d cleanup, exit\n", (int)pst->ptid);
    
37. }
    
38. 
    
39. void *loop(void *p)
    
40. {
    
41.     struct thread_st *pst = p;
    
42.     pthread_cleanup_push(fclean, p);
    
43.     while (1) {
    
44.         printf("%d running\n", (int)pst->ptid);
    
45.         sleep(1);
    
46.     }
    
47.     pthread_cleanup_pop(0);
    
48.     return 0;
    
49. }
    
50. 
    
51. void *monitor(void *p)
    
52. {
    
53.     size_t i;
    
54.     while (1) {
    
55.         for (i = 0; i < N; ++i) {
    
56.             if (time(NULL) - pst[i].ctime > 3) {
    
57.                 pthread_cancel(pst[i].ptid);
    
58.                 pthread_join(pst[i].ptid, NULL);
    
59.                 pthread_create(&pst[i].ptid, NULL, loop, pst + i);
    
60.                 pst[i].ctime = time(NULL);
    
61.             }
    
62.         }
    
63.         sleep(1);
    
64.     }
    
65.     return 0;
    
66. }

复制代码

我模拟你的程序，写了测试程序，线程清理函数是执行了的。
一个 pthread_cancel 并不等待线程退出，也就是说这个函数调用后，进程仍然在，这个时候马上创建新线程，并使用这个插槽，相当与新旧线程共用一个插槽，资源泄漏是不是和这个有关。
我的程序里增加了join，cancel之后，等待老线程退出，才创建新的线程。

问题2，我碰到的情况是，如果不是detach的线程，只有join才会回收线程本身的资源，这些不包括分配在堆上的内存。如果不join，且没有detach，则线程自身的资源也不回收，频繁的创建/删除进程，这个资源浪费，也很可观。

davelv

我的线程插槽和需要清理的数据并不冲突，所以不会出现这样的问题。
而且我也试过join，但是没有效果。
都不知道到底是哪里出问题了头大。。
谢谢楼上还有5楼的回答

davelv

最后的结果是，我在线程里面调用的某个函数会影响线程的清理。把清理写到线程结束后临时解决了此问题。