[原创]reentrant函数与thread safe函数浅析

ypxing

在多线程条件下，
理论上,将malloc放入signal的handler也是会出问题的,
锁是不行的,会死锁

原帖由 bluster 于 2007-8-9 10:08 发表

多线程条件下，signal的handler有可能在一个单独的线程中执行，如果这样那么malloc用锁保护就够了。

ypxing

试图测试malloc不可重入性的代码如下:

1. 
   
2. main.c
   
3. /*这是主程序,用来调用malloc*/
   
4. 
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <signal.h>
   
8. #include <string.h>
   
9. #include <sys/types.h>
   
10. #include <unistd.h>
    
11. 
    
12. void setUnblock()
    
13. {
    
14.   sigset_t sigset;
    
15.   sigemptyset(&sigset);
    
16.   sigprocmask(SIG_SETMASK, &sigset, NULL);
    
17.       
    
18. }
    
19. 
    
20. 
    
21. void usr1Handler (int signal_number)        /*处理SIGUSR1信号*/
    
22. {
    
23.   setUnblock(); /*使得SIGUSR1可以被嵌套*/
    
24.   free((int*)malloc(sizeof(int)*1000));
    
25.   //printf("enter handler\n");
    
26.   //getchar();
    
27. }
    
28. 
    
29. int main ()
    
30. {
    
31.   int *pi;
    
32.   struct sigaction sa;
    
33.   
    
34.   memset(&sa, 0, sizeof(sa));
    
35.   sa.sa_handler = &usr1Handler;
    
36.   sigaction(SIGUSR1, &sa, NULL);
    
37. 
    
38.   pause();
    
39.   
    
40.   return 0;
    
41. }
    
42. 
    
43. 
    

复制代码

1. 
   
2. kill.c
   
3. 
   
4. /*这个是用来发送SIGUSR1信号的*/
   
5. #include <stdlib.h>
   
6. #include <stdio.h>
   
7. #include <string.h>
   
8. 
   
9. int main(int argc,char *argv[])
   
10. {
    
11.   int i;
    
12.   char killstr[30]="kill -USR1 ";
    
13.   if (argc == 2)
    
14.   {
    
15.     strcat(killstr, argv[1]);
    
16.   }
    
17.    for (i=0; i<3; i++)
    
18.   {
    
19.    fork();        /*这样会有8个进程同时发送*/
    
20.   }
    
21.   
    
22.   while(1)
    
23.   {
    
24.     system(killstr);
    
25.   }
    
26.   
    
27.   return 0;
    
28. }
    
29. 
    

复制代码

验证方法是:
1. 编译main.c 和kill.c
gcc main.c -o main
gcc kill.c -o kill

2. 运行./main
并在另外一个终端运行ps -A|grep main查找出该进程的进程号为pid

3. 运行./kill pid (此处pid为第二步查到的pid)

运行了很长时间,也没有crash
请大家看看我的程序,讨论一个测试方案出来

原帖由 ypxing 于 2007-8-8 23:05 发表
这两天写了一个测试程序来验证malloc的不可重入性
但是malloc一直没有crash,有点郁闷

过段时间把自己的测试代码贴出来,让大家来帮忙看看

mingyanguo

原帖由 ypxing 于 2007-8-9 16:22 发表
试图测试malloc不可重入性的代码如下:


main.c
/*这是主程序,用来调用malloc*/

#include
#include
#include
#include
#include
#include

void setUnblock()
{
  sigset_t sigset;
  s ...

我估计是因为现在的malloc是线程安全的原因所以不会crash但是死锁。
我在debian上面的一个测试代码，会死锁，top一下会发现进程状态总是sleep

1. 
   
2. #include <sys/types.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <signal.h>
   
6. #include <unistd.h>
   
7. 
   
8. #if        0
   
9. #define        PRINT(a)        do {        \
   
10.         printf a;                \
    
11.         fflush(stdout);                \
    
12. }while(0)
    
13. #else
    
14. #define        PRINT(a)
    
15. #endif
    
16. 
    
17. static void
    
18. run_malloc(void)
    
19. {
    
20.         void        *mem[8];
    
21.         int        sz;
    
22.         int        i;
    
23. 
    
24.         for (i = 0; i < (sizeof(mem)/sizeof(mem[0])); i++) {
    
25.                 sz = random() % (1024 * 1024);
    
26.                 if (sz <= 0)
    
27.                         sz = 1024;
    
28.                 mem[i] = malloc(sz);
    
29.                 if (mem == NULL) {
    
30.                         PRINT (("[%d] malloc null...\n", i));
    
31.                         exit(-1);
    
32.                 }
    
33.                 PRINT(("%d\n", i));
    
34.                 snprintf(mem[i], sz, "this is a test...");
    
35.         }
    
36. 
    
37.         for (--i; i >= 0; i--) {
    
38.                 free(mem[i]);
    
39.         }
    
40. }
    
41. 
    
42. static void
    
43. sighandler(int signo)
    
44. {
    
45.         static void *mem = NULL;
    
46. 
    
47.         PRINT ((".\n"));
    
48.         if (mem == NULL) {
    
49.                 mem = malloc(1024);
    
50.         } else {
    
51.                 free(mem);
    
52.                 mem = NULL;
    
53.         }
    
54. }
    
55. 
    
56. static void
    
57. malloc_loop(void)
    
58. {
    
59. 
    
60.         for (;;)
    
61.                 run_malloc();
    
62. }
    
63. 
    
64. static void
    
65. signal_loop(pid_t child)
    
66. {
    
67.         int        usec;
    
68. 
    
69.         for (;;) {
    
70.                 kill(child, SIGUSR1);
    
71.                 usec = ((unsigned int)random()) % 10;
    
72.                 usleep(usec);
    
73.         }
    
74. }
    
75. 
    
76. int
    
77. main(int argc, char **argv)
    
78. {
    
79.         pid_t        child;
    
80. 
    
81.         if ((child = fork()) < 0) {
    
82.                 perror("fork()");
    
83.                 exit(-1);
    
84.         } else if (child == 0) {
    
85.                 /* child */
    
86.                 if (signal(SIGUSR1, sighandler) < 0) {
    
87.                         perror("signal");
    
88.                         exit(-1);
    
89.                 }
    
90.                 malloc_loop();
    
91.         } else {
    
92.                 /* parent */
    
93.                 signal_loop(child);
    
94.         }
    
95. 
    
96.         return        0;
    
97. }
    
98. 
    
99. 
    

复制代码

haohao06

谢谢楼主讲解.收藏先

system888net

顶...

dxcnjupt

不知道这个理解对不对：
thread-safe和reentrant的区别:在发生中断时，高优先级代码抢占，此时若低优先级代码持有锁，则高优先级代码会一直等待锁打开，但是低优先级代码失去了调度机会，于是造成死锁。thread-safe不考虑这种情况，但是reentrant需要。

实现reentrant的几种方法：
1不使用临界区，把原先的全局/静态变量变成函数参数，由函数调用者维护。优点是实现简单，缺点是函数功能的封装性可能会受到影响。
2在进入临界区之前，关中断（屏蔽信号）。优点是实现简单，缺点是影响实时性能，在多核机器上可能引起瓶颈（几个核等待一个核释放信号量）。
3尝试加锁，无法加锁返回一个出错值，而不是一直等待下去。缺点是出错处理比较麻烦
4为一组临界量开启一个专门的线程进行处理。优点是可以对临界区的访问按优先级排序，以及其它可扩展操作，缺点是性能受到IPC的影响。
5使用lock-free结构取代锁。缺点是lock-free算法很多都需要memory-copy，影响效率。

fswenly

学习了，谢谢！

fswenly

嗯，学习了，谢谢分享。