【译】编写可重入和线程安全的代码

 

编写可重入和线程安全的代码

(http://www.ualberta.ca/dept/chemeng/AIX-43/share/man/info/C/a_doc_lib/aixprggd/genprogc/writing_reentrant_thread_safe_code.htm)

 

     单线程的进程中仅有一个控制流。这种进程执行的代码无需可重入或线程安全。在多线程的程序中，同一函数或资源可能被多个控制流并发访问。为保护资源完整性，多线程程序编码必须可重入且线程安全。

     本节提供了一些编写可重入和线程安全程序的(指导)信息，但不包括编写线程高效程序的主题。线程高效程序是高效并行化的程序，仅可在程序设计中实现。现有的单线程程序可变得线程高效，但这需要完全地重新设计和重写。

Ÿ 

理解可重入性和线程安全性

     可重入和线程安全与函数处理资源的方式有关。可重入和线程安全是两个相互独立的概念：一个函数可以仅是可重入的，可以仅是线程安全的，可以两者皆是或两者皆不是。

可重入性

     可重入函数不能为后续的调用保持静态(或全局)数据，也不能返回指向静态(或全局)数据的指针。函数中用到的所有数据，都应由函数调用者提供(不包括栈上的局部数据)。可重入函数不能调用不可重入的函数。

     不可重入的函数经常(但不总是)可以通过其外部接口和用法识别。例如strtok子例程是不可重入的，因为它保存着将被分隔为子串的字符串。ctime也是不可重入的，它返回一个指向静态数据的指针，每次调用都会覆盖这些数据。

线程安全性

     线程安全的函数通过“锁”来保护共享资源不被并发地访问。“线程安全”仅关心函数的实现，而不影响其外部接口。

     在C中，局部变量在栈上动态分配，因此，任何不使用静态数据和其它共享资源的函数就是最普通的线程安全(函数)。例如，以下函数就是线程安全的：

1 /* thread-safe function */
2 int diff(int x, int y)
3 {
4         int delta;
5         delta = y - x;
6         if (delta < 0)
7             delta = -delta;
8         return delta;
9 }
View Code

     使用全局数据是线程不安全的。应为每个线程维护一份全局数据的拷贝或封装全局数据，以使对它的访问变成串行的。线程可能读取另一线程造成的错误对应的错误码。在AIX系统中，每个线程拥有属于自己的错误码(errno)值。

 

编写可重入函数

    在大部分情况下，不可重入的函数修改为可重入函数时，必须修改函数的对外接口。不可重入的函数不能用于多线程。此外，也许不可能让某个不可重入的函数是线程安全的。

返回数据

     很多不可重入的函数返回一个指向静态数据的指针。这可通过两种方法避免：

  • 返回从堆中动态分配的数据(即内存空间地址)。在这种情况下，调用者负责释放堆中的存储空间。其优点是不必修改函数的外部接口，但不能保证向后兼容。现有的单线程程序若不修改而直接使用修改后的函数，将不会释放存储空间，进而导致内存泄露。
  • 由调用者提供存储空间。尽管函数的外部接口需要改变，仍然推荐使用这种方法。

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

 1 /* non-reentrant function */
 2 char *strtoupper(char *string)
 3 {
 4         static char buffer[MAX_STRING_SIZE];
 5         int index;
 6  
 7         for (index = 0; string[index]; index++)
 8             buffer[index] = toupper(string[index]);
 9         buffer[index] = 0;
10  
11         return buffer;
12 }
View Code

     该函数既不是可重入的，也不是线程安全的。使用第一种方法将其改写为可重入的，函数将类似于如下代码片段：

 1 /* reentrant function (a poor solution) */
 2 char *strtoupper(char *string)
 3 {
 4         char *buffer;
 5         int index;
 6  
 7         /* error-checking should be performed! */
 8         buffer = malloc(MAX_STRING_SIZE);
 9  
10         for (index = 0; string[index]; index++)
11             buffer[index] = toupper(string[index]);
12         buffer[index] = 0;
13  
14         return buffer;
15 }
View Code

     更好的解决方案是修改接口。调用者须为输入和输出字符串提供存储空间，如下代码片段所示：

 1 /* reentrant function (a better solution) */
 2 char *strtoupper_r(char *in_str,  char *out_str)
 3 {
 4         int index;
 5  
 6         for (index = 0; in_str[index]; index++)
 7             out_str[index] = toupper(in_str[index]);
 8         out_str[index] = 0;
 9  
10         return out_str;
11 }
View Code

     通过使用第二种方法，不可重入的C标准库子例程被改写为可重入的。见下文讨论。 

为连续调用保持数据

     (可重入函数)不应为后续调用保持数据，因为不同线程可能相继调用同一函数。若函数需要在连续调用期间维持某些数据，如工作缓存区或指针，则该数据(资源)应由调用方函数提供调用者应该提供。

     考虑如下示例。函数返回字符串中的连续的小写字符。字符串仅在第一次调用时提供，类似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;
}
View Code

     该函数是不可重入的。为使它可重入，静态数据(即index变量)需由调用者来维护。该函数的可重入版本实现可能如下代码片段所示：

 1 /* reentrant function */
 2 char reentrant_lowercase_c(char *string, int *p_index)
 3 {
 4         char c = 0;
 5  
 6         /* no initialization - the caller should have done it */
 7  
 8         /* searches a lowercase character */
 9         for (; c = string[*p_index]; (*p_index)++) {
10             if (islower(c)) {
11                 (*p_index)++;
12                 break;
13             }
14         }
15         return c;
16 }
View Code

     函数的接口和用法均发生改变。调用者每次调用时必须提供该字符串，并在首次调用前将索引(index)初始化为0，如下代码片段所示：

1 char *my_string;
2 char my_char;
3 int my_index;
4 ...
5 my_index = 0;
6 while (my_char = reentrant_lowercase_c(my_string, &my_index)) {
7         ...
8 }
View Code

 

编写线程安全函数

     在多线程程序中，所有被多线程调用的函数都必须是线程安全的。然而，在多线程程序中可变通地使用线程不安全的子例程。注意，不可重入的函数通常都是线程不安全的，但将其改写为可重入时，一般也会使其线程安全。

对共享资源加锁

     使用静态数据或其它任何共享资源(如文件或终端)的函数，必须对这些资源加“锁”来串行访问，以使该函数线程安全。例如，以下函数是线程不安全的：

1 /* thread-unsafe function */
2 int increment_counter()
3 {
4         static int counter = 0;
5  
6         counter++;
7         return counter;
8 }
View Code

     为使该函数线程安全，静态变量counter需要被静态锁保护，如下例(伪代码)所示：

 1 /* pseudo-code thread-safe function */
 2 int increment_counter();
 3 {
 4         static int counter = 0;
 5         static lock_type counter_lock = LOCK_INITIALIZER;
 6  
 7         lock(counter_lock);
 8         counter++;
 9         unlock(counter_lock);
10         return counter;
11 }
View Code

     在使用线程库的多线程应用程序中，应使用信号量互斥锁(mutex)来串行访问共享资源，独立库可能需要工作于线程上下文之外，因此使用其他类型的锁。 

线程不安全函数的变通方案

     多线程变通地调用线程不安全函数是可能的。这在多线程程序使用线程不安全库时尤其有用，如用于测试或待该库的线程安全版本可用时再予以替换。该变通方案会带来一些开销，因为需对整个函数甚至一组函数进行串行化。

  • Ÿ对该库使用全局锁，每次使用库(调用库内子例程或使用库内全局变量)时均对其加锁，如下伪代码片段所示：
1     /* this is pseudo-code! */
2     lock(library_lock);
3     library_call();
4     unlock(library_lock);
5 
6     lock(library_lock);
7     x = library_var;
8     unlock(library_lock);
View Code

     该方案可能产生性能瓶颈，因为任一时刻仅有一个线程可访问库的任一部分。仅当不常访问库，或作为初步快速实现的权宜之计时可以采用该方案。

  • 对每个库组件(例程或全局变量)或一组组件使用锁，如下例伪代码片段所示： 
1     /* this is pseudo-code! */
2     lock(library_moduleA_lock);
3     library_moduleA_call();
4     unlock(library_moduleA_lock);
5     
6     lock(library_moduleB_lock);
7     x = library_moduleB_var;
8     unlock(library_moduleB_lock);
View Code

     该方案实现相比前者稍微复杂，但可提高性能。

     该方案应仅用于应用程序而非库，故可用互斥锁对库加锁。

 

可重入和线程安全库

     可重入和线程安全库广泛应用于并行(和异步)编程环境，而不仅仅用于线程内。因此，总是使用和编写可重入和线程安全的函数是良好的编程实践。

使用函数库

     AIX基本操作系统附带的几个代码库是线程安全的。在AIX当前版本中，以下库是线程安全的。

  • Ÿ   C标准函数库(libc.a)
  • Ÿ   BSD兼容函数库(libbsd.a)

     某些标准C子例程是不可重入的，如ctime和strtok子例程。它们的可重入版本函数名是原始子例程名添加"_r"后缀。

     在编写多线程程序时，应使用子例程的可重入版本来替代原有版本。例如，以下代码片段：

1 token[0] = strtok(string, separators);
2 i = 0;
3 do {
4         i++;
5         token[i] = strtok(NULL, separators);
6 } while (token[i] != NULL);
View Code

     在多线程程序中应替换为以下代码片段：

1 char *pointer;
2 ...
3 token[0] = strtok_r(string, separators, &pointer);
4 i = 0;
5 do {
6         i++;
7         token[i] = strtok_r(NULL, separators, &pointer);
8 } while (token[i] != NULL);
View Code

     线程不安全库可用于单线程程序中。程序员必须确保使用该库的线程唯一性；否则，程序行为不可预料，甚至可能崩溃。

改写函数库

    以下信息突出了将现有库转换为可重入和线程安全库的主要步骤(仅适用于C语言代码库)。

  • 识别对外的全局变量。这些变量通常在头文件中用export关键字定义*。

       【译者注：应为”用extern关键字声明”】

       应封装对外的全局变量。该变量应改为私有(在库源代码内用static关键字定义)。应创建(读写)该变量的子例程。

  • 识别静态变量和其他共享资源。静态变量通常用static关键字定义。

        任一共享资源均应与锁关联。锁的粒度及数目会影响库的性能。可使用”一次性初始化”特性(如pthread_once)来方便地初始化锁。

  • 识别不可重入函数并使之变为可重入函数。见”编写可重入函数“。
  • 识别线程不安全函数并使之变为线程安全函数。见”编写线程安全函数“。

 

 

posted @ 2014-05-21 09:18  clover_toeic  阅读(2994)  评论(2)  编辑  收藏  举报