函数的可重入和线程安全

　　函数的可重入和线程安全是针对于2种不同的使用场景提出的概念。

　　可重入函数这一概念是针对于一个进程中单个线程，指的是一个函数如果在调用期间被中断，在中断中再次进入这个函数执行完毕后，恢复原来的中断点执行时，不会出现错误。

　  线程安全这个概念是针对多进程，多线程编程中产生的。指的是一个函数被并发调用时，任意一个调用不会影响到它的另一个调用。一个函数对多个线程来说是可重入的，那么它就是线程安全的。

 

　可重入

　　信号可以视为软件中断，在信号处理函数中举例不可重入函数:

　　　　1.函数中使用了静态变量

#include <signal.h>
#include <stdio.h>

char *foo(char *str)
{
    static char buffer[1024];
    int index;
    
    for (index = 0; str[index]; index++)
    {
        buffer[index] = toupper(str[index]);
    }
    buffer[index] = '\0';
    return buffer;
}

void signal_handler(int signum)
{
    foo("aaaaaaa");
}

int main (void)
{
    char *str;
    signal (SIGINT, signal_handler);
    
    while (1)
    {
        str = foo("zzzzzz");
    }
}

 

　　设想，如果main中对foo的调用执行到13行时buffer的内容应该是"ZZZZZZ"，这时来了一个信号，转而执行信号处理函数，它执行完毕buff内容为“AAAAAAA"，这时恢复到原来的main中对foo的调用中断点13行继续执行到返回，发现str指向的内容不是预期的"ZZZZZ",而是"AAAAAA"。由此可见这个函数是不可重入的。

　　2.使用全局变量，并且没对全局变量进行现场保护

#include <signal.h>
#include <stdio.h>

int a = 0;

int foo(void)
{
    a++;
    return a;
}

void signal_handler(int signum)
{
    foo();
}

int main (void)
{
    signal (SIGINT, signal_handler);
    foo();
}

 

　　同样的分析，main中的调用执行到第9行，来了中断，结果是14行和20行的返回值是一样的，显然和预期不一样，其实可以通过用一个局部变量来解决这个问题，修改一下信号处理函数：

void signal_handler(int signum)
{
    int tmp_a;
    tmp_a = a;
    foo();
    a = tmp_a;
}

 

　　这样就可以看到预期的结果了。

---

 

　　线程安全

　　那么什么样的函数又不是非线程安全的呢？举几个反例。

1. 　　函数中使用静态变量

void foo(void)
{
    int n = 10000000;
    static int i = 0;

    i++;

    while ( n-- );
    printf("run foo i:%d\n\n",i);
}

void *threadfun1(void *arg)
{
    foo();
    return (void *)0;
}

void *threadfun2(void *arg)
{
    foo();
    return (void *)0;
}

　　2个线程运行起来，按照正常的运行结果，多次运行这个程序，输出应该是一样的，但是运行后发现：

thomas@thomas-laptop:~/test$ ./a
run foo i:2

run foo i:2

thomas@thomas-laptop:~/test$ ./a
run foo i:2

run foo i:1

thomas@thomas-laptop:~/test$ ./a
run foo i:1

run foo i:1

运行完全乱套，这是为什么呢？线程有2个，但是静态变量i却是共享的同一个。

　　2. 　使用全局变量

　　若把上面的 i 定义为全局变量也会出现同样的问题，原因也是多个线程共享了同一个数据，没做好竞态资源的访问管理。针对全局变量，可以通过一个互斥锁解决这个问题。

int i = 0;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void foo(void)
{
    int n = 100000;

    pthread_mutex_lock(&mtx);
    i++;
    while ( n-- );
    printf("run foo i:%d\n\n",i);
    pthread_mutex_unlock(&mtx);
}　　

　　线程不安全函数可以使用某些手段，比如上面用到的mutex来解决，使其成为线程安全的，但是却无法成为一个可重入的函数，例如如果在加锁后出现中断，进入函数再次加锁，结果出现了死锁，就算使用trylock来测试，避免死锁，共享变量的现场依旧没有被保护，仍然是不可重入的。