malloc() is non-reentrant but thread-safe? [duplicate]

Question

Possible Duplicate:
Malloc thread-safe?

I am not a bit confused while I am reading "The Linux Programming Interface".

From the book it says that malloc is non-reentrant since it manipulates the global linked list data structure but is made thread-safe by using mutex.

I am a bit confused about this: since it's thread-safe with using mutex and thus can be invoked by more than one threads at the same time, why it isn't a reentrant function? (if we say that reentrant means that it can be invoked by more than one caller at the same time)

Another question is that, since malloc is thread-safe, can we put it in a signal handler? I think the answer is yes but I am not sure since according to this book, it says that only a reentrant or async-signal-safe function can be put in the signal handler.

Can anyone explain this to me?

Answer 1

if we say that reentrant means that it can be invoked by more than one caller at the same time

Wrong. Reentrant means you can interrupt it and call it again before the previous incarnation ended. Imagine malloc looks like this:

lock(mutex);

/* Stuff. */

unlock(mutex):

What happens if it is interrupted in the middle, before unlocking and someone else calls malloc ?

• The first context cannot continue until the second one is done
• The second context blocks on the mutex and cannot continue until the first unlocks the mutex

That's a deadlock.

Another question is that, since malloc is thread-safe, can we put it in a signal handler? I think the answer is yes

Wrong again. See the example above. Imagine the main program is doing a malloc and before the function actually ends your handler calls malloc.

Answer 2

Reentrancy and thread-safety are two different concepts. A reentrant function can be non-thread -safe and a thread-safe function can be non-reentrant.

Library functions in C are not guaranteed to be reentrant and only reentrant functions can be called from signal handlers.