不可重入函数意味着将有一个静态上下文，由函数维护。第一次进入时，将为您创建新的上下文。下一个输入，你不需要发送更多的参数，为了方便标记分析。例如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.

共同点是:

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

如果你有这样一个函数:

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

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

如果你有这样一个函数:

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

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

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

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

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

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

NO!

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

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

NO!

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

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

NO!

见上图。

你的“同样”问题的答案是“不”，“不”和“不”。仅仅因为函数是递归的和/或线程安全的，并不意味着它是可重入的。

每一种类型的函数都可能在你引用的所有点上失败。(虽然我不是100%确定第五点)。

不可重入函数意味着将有一个静态上下文，由函数维护。第一次进入时，将为您创建新的上下文。下一个输入，你不需要发送更多的参数，为了方便标记分析。例如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.

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

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

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

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

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

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

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

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

malloc(heap*, size_t);

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

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