Reentrantsafe

Reentrantsafe is a designation used in software development to describe a component, typically a function, that can be safely called again before its previous invocation has finished. The reentrancy property is important in contexts where code may be interrupted by an asynchronous event such as a hardware interrupt, a signal handler, or concurrent threads.

To be reentrantly safe, a function should not rely on non-constant, globally shared state without proper synchronization. It should avoid using non-reentrant library calls, static or global variables that are modified, and resources that are not reentrant. It should use only local variables or data passed by the caller, and allocate memory in a way that cannot leak or conflict across reentries (or avoid dynamic allocation entirely). If shared resources must be accessed, they should be protected with reentrancy-friendly mechanisms or passed in via parameters. A typical guideline is to keep the function small and free of side effects, or to design the function to operate on per-call context.

Relationship to thread safety and async-signal safety: Reentrancy is related but distinct from thread-safety. A reentrant function is not necessarily thread-safe under all interleavings, and a thread-safe function may still not be reentrant if it relies on shared non-reentrant state across calls. In the POSIX context, async-signal-safe functions are a stricter subset of reentrant-safe functions, safe to call from signal handlers.

Examples: A function that uses a global counter without synchronization would not be reentrant. A function that only uses its local stack, constants, and the caller-provided context is reentrant. Code bases often annotate functions as reentrantsafe to aid embedded systems and kernel development.