线程安全

概念：

当多个线程访问同一个对象时，如果不用考虑这些线程在当前运行环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。

或者说一个类或者程序所提供的接口对线程来说是原子操作或者多个线程的切换不会导致该接口执行结果的二义性，那我们说这个接口是不用考虑线程安全问题的。

造成线程安全问题的原因：线程安全问题都是由于静态变量或者全局变量的使用问题造成的。

由于全局变量和静态变量的作用域范围都是一个进程之内可见，而一个进程之内的多个线程也会使用同一份全局或者静态变量，当一个线程修改了一个全局变量或者静态变量的值时，另一个线程再去访问该变量，所得到的结果可能就不在是自己所期望的，这就是线程的安全问题。

线程不安全函数示例：strtok函数的线程安全问题

strtok函数的定义如下：

#include<string.h>
char *strtok(char *strToken, const char *strDelimit );
                            //根据strDelimit将strToken分割，返回每次分割的元素地址

它的作用是切割字符串，strtoken指针存储的就是源字符串，strDelimit指针存储的是切割标志，当在源字符串中遇到标志字符时，就会在标志字符出现的位置将该标志字符替换成‘\0’，然后返回该标志字符前面的一个子串（如果标志字符是一个字符串，则该标志字符串中的每一个字符都是标志字符）

第一次调用该函数时，要传入源字符串的地址指针和标志字符，而第二次分割时，直接传入一个NULL和标志字符就可以，为什么直接传入一个NULL就可以呢？这也是其线程安全问题的所在！

strtok函数中有一个SAVE_PTR的一个静态指针，这个指针中就保存了上次运行时切割后剩余字符串的首地址，也就是标志字符的地址加一，当我们再次调用该函数时，会从该静态指针中取出该地址进行切割，这个时候问题就来了，如果有多个线程同时使用该函数，而由于这个SAVE_PTR指针是一个静态指针，整个进程中只有一份，所有线程共享该静态指针，在两个不同的线程使用该函数切割各自的字符串时，就有可能发生线程安全问题（A线程使用了B线程的SAVE_PTR指针，切割了B线程的字符串）

#include<stdio.h>
#include<string.h>
#include<pthread.h>
//函数线程，以空格为标志切割字符串“1 2 3 4 5 6 7 8 9”
void *fun(void *arg)
{
    char buff[] = "1 2 3 4 5 6 7 8 9";
    char *p = strtok(buff, " ");
    while(p != NULL)
    {
        printf("fun:%s\n", p);
        p = strtok(NULL, " ");
    }
}

//主线程,以空格为标志切割字符串“a b c d e f g h i”
int main()
{
    pthread_t id;
    pthread_create(&id, NULL, fun, NULL);//启动函数线程
    char buff[] = "a b c d e f g h i";
    char *p = strtok(buff, " ");
    while(p != NULL)
    {
        printf("main:%s\n", p);
        p = strtok(NULL, " ");
    }
    pthread_exit(NULL);
    return 0;
}

我们所期望的运行结果：

main:a
fun:1
main:b
fun:2
main:c
fun:3
main:d
fun:4
main:e
fun:5
main:f
fun:6
main:g
fun:7
main:h
fun:8
main:i
fun:9

实际的运行结果：

显然这不是我们所期望的结果，这就是线程安全问题带来的后果。

类似于strtok函数的线程不安全的函数还有很多：

那为了解决线程安全问题，操作系统实现支持线程安全函数这一特性时，对上表中这些线程不安全的函数，提供了可替代的线程安全版本。

这些函数要求调用者自己提供缓冲区使其变成安全的。什么意思呢，也就是说，当我们要使用进程中的全局变量或者静态变量时，我们在自己提供的缓冲区中将其拷贝下来，只对我们拷贝下来的这份数据进行改动，而不会真正去改变这个进程中的数据。

线程安全函数示例：strtok_r函数的线程安全

和strtok函数示例相同我们要在两个线程中实现对各自字符串中的分割输出，不同的是我们这次使用线程安全的strtok_r函数。strtok_r函数的定义如下：

#include<string.h>
char *strtok(char *strToken, const char *strDelimit, char **saveptr);

我们可以看到这个strtok_r函数比strtok函数多了一个参数：saveptr，这个二级指针是我们自己定义的一个指针变量的地址，是一个局部变量，局部变量对线程来说也是不共享的就是用来代替strtok函数中那个静态指针SAVE_PTR的，将下一次要切割字符串的首地址保存在我们提供的这个缓冲区中，而不再直接改变静态变量或者全局变量的值，达到线程安全的效果。

#include<stdio.h>
#include<string.h>
#include<pthread.h>

void *fun(void *arg)
{
    char buff[] = "1 2 3 4 5 6 7 8 9";
    char *q = NULL;//我们自己提供的缓冲区，用来保存下以次开始切割的地址
    char *p = strtok_r(buff, " ", &q);
    while(p != NULL)
    {
        printf("fun:%s\n",p);
        p = strtok_r(NULL, " ", &q);
    }
}

int main()
{
    pthread_t id;
    pthread_create(&id, NULL, fun, NULL);
    char buff[] = "a b c d e f g h i";
    char *q = NULL;
    char *p = strtok_r(buff, " ", &q);
    while(p !+ NULL)
    {
        printf("main:%s\n", p);
        p = strtok_r(buff, " ", &q);
    }
    pthread_exit(NULL);
    return 0;
}

运行结果：

我们可以看出使用这个函数打印出来的结果就是我们所期望的结果，函数线程切割输出数字，主线程切割输出字母。而我们也没有使用其他保证线程安全的手段。说明strtok_r函数是线程安全的函数。

为什么这个strtok_r函数和这个strtok函数的函数名如此相同，他们俩之间的联系是什么呢？其实，strtok_r函数是strtok函数的可重入版本，也就是为了保证线程安全而对strtok函数做的改进。

重入：

之前我们使用的strtok函数，由于在一个进程中它会使用相同的静态指针SAVE_PTR，因此一个进程中即便你多次调用strtok函数，它也只会使用相同的一个SAVE_PTR,因此这个函数是不可重入的，而当我们使用strtok_r函数时，在一个进程中多次调用它，彼此之间没有联系，互不干扰，这就被称作可重入的。

可重入函数的要求：

• 不使用全局变量或者静态变量
• 不使用malloc或者new出来的堆区空间
• 不调用不可重入函数
• 不返回全局数据或者静态数据，所有数据都由函数的调用者提供
• 使用本地数据，或者通过使用全局数据的本地拷贝来保护全局数据

不可重入函数的特点：

• 调用了malloc/new函数，因为malloc底层是用全局链表来管理堆区空间的，而new的底层实现使用了malloc
• 可重入体内使用了静态的数据结构
• 调用了标准I/O库函数，标准I/O库函数很多都以不可重入的方式使用了全局数据结构