现在我要详细说明一下我刚才的评论。@paercebal回答不正确。在示例代码中，难道没有人注意到应该是参数的互斥量实际上没有传入吗?

我对这个结论提出异议，我断言:一个函数要在并发性存在的情况下是安全的，它必须是可重入的。因此，并发安全的(通常是编写线程安全的)意味着可重入。

无论是线程安全的还是可重入的，都与参数无关:我们讨论的是函数的并发执行，如果使用了不适当的参数，仍然可能是不安全的。

例如，memcpy()是线程安全的和可重入的(通常)。显然，如果从两个不同的线程调用指向相同目标的指针，它将无法正常工作。这就是SGI定义的要点，将确保对相同数据结构的访问由客户端同步的责任放在了客户端身上。

重要的是要理解，在一般情况下，让线程安全操作包含参数是没有意义的。如果你做过数据库编程，你就会明白。“原子的”概念以及可能由互斥锁或其他技术保护的概念必然是用户概念:在数据库上处理事务可能需要多次不间断的修改。除了客户端程序员，谁能说哪些需要保持同步呢?

关键是，“损坏”并不一定要用非序列化的写入来搞乱您计算机上的内存:即使所有单独的操作都是序列化的，损坏仍然可能发生。因此，当您询问一个函数是否是线程安全的或可重入的时，这个问题意味着所有适当分离的参数:使用耦合参数并不构成反例。

有很多编程系统:Ocaml是其中之一，我认为Python也是，它们有很多不可重入的代码，但是使用全局锁来交错线程访问。这些系统不是可重入的，它们不是线程安全的或并发安全的，它们安全运行只是因为它们阻止了全局并发。

malloc就是一个很好的例子。它不是可重入的，也不是线程安全的。这是因为它必须访问全局资源(堆)。使用锁并不能保证它的安全性:它绝对不能重入。如果malloc的接口设计得当，就有可能使其可重入且线程安全:

malloc(heap*, size_t);

现在它是安全的，因为它将序列化对单个堆的共享访问的责任转移到客户机。特别是，如果存在单独的堆对象，则不需要做任何工作。如果使用公共堆，客户端必须序列化访问。在函数内部使用锁是不够的:只考虑一个malloc锁定一个堆*，然后一个信号出现并在同一个指针上调用malloc:死锁:信号不能继续，客户端也不能继续，因为它被中断了。

一般来说，锁并不能使事情变得线程安全。它们实际上破坏了安全性，因为它们不恰当地试图管理客户端拥有的资源。锁定必须由对象制造商完成，这是唯一的代码，知道有多少对象被创建和他们将如何使用。

现在我要详细说明一下我刚才的评论。@paercebal回答不正确。在示例代码中，难道没有人注意到应该是参数的互斥量实际上没有传入吗?

我对这个结论提出异议，我断言:一个函数要在并发性存在的情况下是安全的，它必须是可重入的。因此，并发安全的(通常是编写线程安全的)意味着可重入。

无论是线程安全的还是可重入的，都与参数无关:我们讨论的是函数的并发执行，如果使用了不适当的参数，仍然可能是不安全的。

例如，memcpy()是线程安全的和可重入的(通常)。显然，如果从两个不同的线程调用指向相同目标的指针，它将无法正常工作。这就是SGI定义的要点，将确保对相同数据结构的访问由客户端同步的责任放在了客户端身上。

重要的是要理解，在一般情况下，让线程安全操作包含参数是没有意义的。如果你做过数据库编程，你就会明白。“原子的”概念以及可能由互斥锁或其他技术保护的概念必然是用户概念:在数据库上处理事务可能需要多次不间断的修改。除了客户端程序员，谁能说哪些需要保持同步呢?

关键是，“损坏”并不一定要用非序列化的写入来搞乱您计算机上的内存:即使所有单独的操作都是序列化的，损坏仍然可能发生。因此，当您询问一个函数是否是线程安全的或可重入的时，这个问题意味着所有适当分离的参数:使用耦合参数并不构成反例。

有很多编程系统:Ocaml是其中之一，我认为Python也是，它们有很多不可重入的代码，但是使用全局锁来交错线程访问。这些系统不是可重入的，它们不是线程安全的或并发安全的，它们安全运行只是因为它们阻止了全局并发。

malloc就是一个很好的例子。它不是可重入的，也不是线程安全的。这是因为它必须访问全局资源(堆)。使用锁并不能保证它的安全性:它绝对不能重入。如果malloc的接口设计得当，就有可能使其可重入且线程安全:

malloc(heap*, size_t);

现在它是安全的，因为它将序列化对单个堆的共享访问的责任转移到客户机。特别是，如果存在单独的堆对象，则不需要做任何工作。如果使用公共堆，客户端必须序列化访问。在函数内部使用锁是不够的:只考虑一个malloc锁定一个堆*，然后一个信号出现并在同一个指针上调用malloc:死锁:信号不能继续，客户端也不能继续，因为它被中断了。

一般来说，锁并不能使事情变得线程安全。它们实际上破坏了安全性，因为它们不恰当地试图管理客户端拥有的资源。锁定必须由对象制造商完成，这是唯一的代码，知道有多少对象被创建和他们将如何使用。

共同点是:

如果在中断时调用例程，行为是否定义良好?

如果你有这样一个函数:

int add( int a , int b ) {
  return a + b;
}

这样它就不依赖于任何外部状态。行为定义良好。

如果你有这样一个函数:

int add_to_global( int a ) {
  return gValue += a;
}

结果在多个线程上没有很好地定义。如果时机不对，信息可能会丢失。

可重入函数的最简单形式是只对传递的参数和常量值进行操作。其他任何东西都需要特殊处理，或者通常是不可重入的。当然参数不能引用可变全局变量。

不可重入函数意味着将有一个静态上下文，由函数维护。第一次进入时，将为您创建新的上下文。下一个输入，你不需要发送更多的参数，为了方便标记分析。例如c中的strtok，如果你没有清楚上下文，可能会有一些错误。

/* strtok example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
  {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
  }
  return 0;
}

on the contrary of non-reentrant, reentrant function means calling function in anytime will get the same result without side effect. because there is none of context. in the view of thread safe, it just means there is only one modification for public variable in current time, in current process. so you should add lock guard to ensure just one change for public field in one time. so thread safety and reentrant are two different things in different views.reentrant function safety says you should clear context before next time for context analyze. thread safety says you should keep visit public field order.

“安全”的定义完全符合常识——它意味着“正确地做自己的事情，而不干扰其他事情”。你提到的六点很清楚地表达了实现这一目标的要求。

你的三个问题的答案是3ד不”。

是否所有递归函数都是可重入的?

NO!

同时调用一个递归函数很容易把彼此搞砸，如果 例如，它们访问相同的全局/静态数据。

是否所有线程安全的函数都是可重入的?

NO!

如果一个函数在并发调用时不发生故障，那么它就是线程安全的。但这可以通过使用互斥来阻止第二次调用的执行，直到第一次调用完成，这样一次只有一个调用可以工作。可重入性意味着在不干扰其他调用的情况下并发执行。

是否所有递归和线程安全的函数都是可重入的?

NO!

见上图。

术语“线程安全的”和“可重入的”的意思完全是它们定义的意思。在这种情况下，“安全”只是指你在下面引用的定义。

这里的“安全”当然不是指更广泛意义上的安全，即在给定的上下文中调用给定的函数不会完全覆盖您的应用程序。总之，一个函数可能在多线程应用程序中可靠地产生期望的效果，但根据定义，它既不符合可重入性，也不符合线程安全。相反，在多线程应用程序中调用可重入函数的方式会产生各种不需要的、意想不到的和/或不可预测的效果。

递归函数可以是任何东西，重入函数的定义比线程安全的更强，所以你的问题的答案都是否定的。

在阅读reentrant的定义时，人们可能会将其总结为一个函数，该函数不会修改任何超出您所要修改的内容的内容。但你不应该只依赖总结。

多线程编程在一般情况下是非常困难的。知道代码的哪一部分可以重入只是这个挑战的一部分。线程安全不是附加的。与其试图将可重入函数拼凑在一起，不如使用整体线程安全的设计模式，并使用此模式来指导程序中每个线程和共享资源的使用。