函数可重入性（Reentrancy)

1.什么是可重入性

重入一般可以理解为一个函数在同时多次调用，例如操作系统在进程调度过程中，或者单片机、处理器等的中断的时候会发生重入的现象。

可重入的函数必须满足以下三个条件：

（1）可以在执行的过程中可以被打断；

（2）被打断之后，在该函数一次调用执行完之前，可以再次被调用（或进入，reentered)。

（3）再次调用执行完之后，被打断的上次调用可以继续恢复执行，并正确执行。

可重入函数可以在任意时刻被中断，稍后再继续运行，不会丢失数据。不可重入（non-reentrant）函数不能由超过一个任务所共享，除非能确保函数的互斥（或者使用信号量，或者在代码的关键部分禁用中断）。

通常，以下几种情况会受到可重入性的制约：

（1）信号处理程序A内外都调用了同一个不可重入函数B；B在执行期间被信号打断，进入A (A中调用了B),完事之后返回B被中断点继续执行，这时B函数的环境可能改变，其结果就不可预料了。
众所周知，在进程中断期间，系统会保存和恢复进程的上下文，然而恢复的上下文仅限于返回地址，cpu寄存器等之类的少量上下文，而函数内部使用的诸如全局或静态变量，buffer等并不在保护之列，所以如果这些值在函数被中断期间发生了改变，那么当函数回到断点继续执行时，其结果就不可预料了。打个比方，比如malloc，将如一个进程此时正在执行malloc分配堆空间，此时程序捕捉到信号发生中断，执行信号处理程序中恰好也有一个malloc，这样就会对进程的环境造成破坏，因为malloc通常为它所分配的存储区维护一个链接表，插入执行信号处理函数时，进程可能正在对这张表进行操作，而信号处理函数的调用刚好覆盖了进程的操作，造成错误。

（2）多线程共享进程内部的资源，如果两个线程A，B调用同一个不可重入函数F，A线程进入F后，线程调度，切换到B，B也执行了F，那么当再次切换到线程A时，其调用F的结果也是不可预料的。

常见的不可重入函数有：
printf --------引用全局变量stdout
malloc --------全局内存分配表
free    --------全局内存分配表

2.可重入与线程安全

可重入的定义源于单线程环境。在单线程环境下，一段代码在执行中可能被硬件中断，并转而调用中断服务程序（ISR）。在本次调用中断处理函数之前，有可能中断处理函数已经在执行。因此，任何中断处理函数都应该是可重入的。

线程安全的概念则源自于多线程环境。可见，他们的起源是不一样的。那么，他们没有什么必然关系呢。可总结如下：

（1）一个线程安全的函数不一定是可重入的；

（2）一个可重入的函数缺也不一定是线程安全的！

3.不可重入的危害

在单线程进程中，只存在一个控制流。因此，这些进程所执行的代码无需重入或是线程安全的。在多线程程序中，相同的功能和资源可以通过多个控制流并发访问。

要保护资源的完整性，编写的多线程程序代码必须能重入并是线程安全的。不可重入对多线程环境的危害是很大的，甚至会造成系统崩溃。

4.不可重入的例子

4.1 不可重入且线程不安全

下面这个swap函数是不可重入的：

[cpp] view plain copy

 print?

1. int t;  
2.    
3. void swap(int *x, int *y)  
4. {  
5.     t = *x;  
6.     *x = *y;  
7.    
8.     // hardware interrupt might invoke isr() here!  
9.     *y = t;  
10. }  
11.    
12. void isr()  
13. {  
14.     int x = 1, y = 2;  
15.     swap(&x, &y);  
16. }  

当然了，跟据前面的总结，既然它不可重入则它一定不是线程安全的。

可以把t改成线程局部变量，使得该函数变成线程安全。然而，这样修改的话，swap函数依然是不可重入的。例如一个线程已经在执行swap函数，这个时候在同样的语境下收到硬件中断，isr()函数会被调用，进而调用swap，swap的不可重入问题就暴露出来了。

4.2 可重入但是线程安全

我们做一定修改，在swap函数里，在交换前，对此时刻的t全局变量做一个本地的缓存，在交换结束的时候，始终使用该缓存。这样的话，swap函数在退出的时候，全局变量的之跟进入的时候是一样的。这样，就可以保证该函数是线程可重入的。代码如下：

[cpp] view plain copy

 print?

1. int t;  
2.    
3. void swap(int *x, int *y)  
4. {  
5.     int s;  
6.    
7.   <span style="color:#FF0000;">  s = t; // save global variable</span>  
8.     t = *x;  
9.     *x = *y;  
10.    
11.     // hardware interrupt might invoke isr() here!  
12.     *y = t;  
13. <span style="color:#FF0000;">    t = s; // restore global variable</span>  
14. }  
15.    
16. void isr()  
17. {  
18.     int x = 1, y = 2;  
19.     swap(&x, &y);  
20. }  

然而，该函数在多线程环境下，依然是线程不安全的，因为它无法保证全局变量t的一致性。

5.预防不可重入的几个原则

原则总结如下：

（1）不要使用static变量和全局变量，坚持只用局部变量；

（2）若必须访问全局变量，利用互斥信号量来保护全局变量；

（3）获取得知哪些系统调用是可重入的，在多任务处理程序中都使用安全的系统调用；

（4）不调用其它任何不可重入的函数；

（5）谨慎使用堆栈malloc/new。

6.优秀实践：如何优化已有代码，使函数成为可重入？

在多数情况下，必须用带有已修改的将要重入的函数来替代非重入函数。非重入函数不能由多个线程使用。此外，可能也无法使非重入函数变为线程安全。

6.1 返回指向静态数据的指针的函数是不可重入的，如何使其变得可重入？

许多非重入函数会返回一个指向静态数据的指针。可以用以下方法来避免这种情况：

• 返回动态分配的数据。在这种情况下，调用程序将负责释放存储量。好处在于无需对接口进行修改。但是，向后兼容性就无法保证了；现有的使用已修改函数的单线程程序在不更改的情况下不会释放存储量，这将导致内存泄漏。
• 使用调用程序提供的存储量。虽然必须修改接口，但是推荐使用这种方法。

例如，将字符串转换为大写的 strtoupper 函数可以用如以下所示的代码段来实现：

/* non-reentrant function */char *strtoupper(char *string){                static char buffer[MAX_STRING_SIZE];                int index;                for (index = 0; string[index]; index++)                                buffer[index] = toupper(string[index]);                buffer[index] = 0                return buffer;}

该函数不是重入函数（也不是线程安全的函数）。要通过返回动态分配的数据来使该函数重入，那么该函数应类似于以下代码段：

/* reentrant function (a poor solution) */char *strtoupper(char *string){                char *buffer;                int index;                /* error-checking should be performed! */                buffer = malloc(MAX_STRING_SIZE);                for (index = 0; string[index]; index++)                                buffer[index] = toupper(string[index]);                buffer[index] = 0                return buffer;}

较好的解决方案是修改接口。调用程序必须为输入和输出字符串提供存储量，如以下代码段所示：

/* reentrant function (a better solution) */char *strtoupper_r(char *in_str, char *out_str){                int index;                for (index = 0; in_str[index]; index++)                out_str[index] = toupper(in_str[index]);                out_str[index] = 0                return out_str;}

使用调用程序提供的存储量使非重入标准 C 库子例程重入。

6.2 在连续调用中保存数据的函数是不可重入的，如何修改？

在连续调用中将不保存任何数据，因为不同的线程可能连续地调用该函数。如果函数必须在连续调用中保存某些数据，比如工作缓存或指针，那么调用程序应提供该数据。

请考虑以下例子。函数返回了字符串中连续的小写字符。该字符串只在第一次调用时提供，就像 strtok 子例程。函数在到达字符串的结尾处时返回 0。该函数可通过以下代码段来实现：

/* non-reentrant function */char lowercase_c(char *string){                static char *buffer;                static int index;                char c = 0;                /* stores the string on first call */                if (string != NULL) {                                buffer = string;                                index = 0;        }                /* searches a lowercase character */                for (; c = buffer[index]; index++) {                                if (islower(c)) {                                                index++;                                                break;                }        }                return c;}

该函数不是重入函数。要使其变为重入函数，那么调用程序必须保存静态数据和变量 index。该函数的重入版本可通过以下代码段来实现：

/* reentrant function */char reentrant_lowercase_c(char *string, int *p_index){                char c = 0;                /* no initialization - the caller should have done it */                /* searches a lowercase character */                for (; c = string[*p_index]; (*p_index)++) {                                if (islower(c)) {                                                (*p_index)++;                                                break;                  }        }                return c;}

该函数的接口和用法都发生了改变。调用程序必须向每次调用提供该字符串，且在首次调用前，必须将索引初始化为 0，如以下代码所示：

char *my_string;char my_char;int my_index;...my_index = 0;while (my_char = reentrant_lowercase_c(my_string, &my_index)) {        ...}