How does malloc work in a multithreaded environment?
glibc 2.15
operates multiple allocation arenas. Each arena has its own lock. When a thread needs to allocate memory, malloc()
picks an arena, locks it, and allocates memory from it.
The mechanism for choosing an arena is somewhat elaborate and is aimed at reducing lock contention:
/* arena_get() acquires an arena and locks the corresponding mutex. First, try the one last locked successfully by this thread. (This is the common case and handled with a macro for speed.) Then, loop once over the circularly linked list of arenas. If no arena is readily available, create a new one. In this latter case, `size' is just a hint as to how much memory will be required immediately in the new arena. */
With this in mind, malloc()
basically looks like this (edited for brevity):
mstate ar_ptr; void *victim; arena_lookup(ar_ptr); arena_lock(ar_ptr, bytes); if(!ar_ptr) return 0; victim = _int_malloc(ar_ptr, bytes); if(!victim) { /* Maybe the failure is due to running out of mmapped areas. */ if(ar_ptr != &main_arena) { (void)mutex_unlock(&ar_ptr->mutex); ar_ptr = &main_arena; (void)mutex_lock(&ar_ptr->mutex); victim = _int_malloc(ar_ptr, bytes); (void)mutex_unlock(&ar_ptr->mutex); } else { /* ... or sbrk() has failed and there is still a chance to mmap() */ ar_ptr = arena_get2(ar_ptr->next ? ar_ptr : 0, bytes); (void)mutex_unlock(&main_arena.mutex); if(ar_ptr) { victim = _int_malloc(ar_ptr, bytes); (void)mutex_unlock(&ar_ptr->mutex); } } } else (void)mutex_unlock(&ar_ptr->mutex); return victim;
This allocator is called ptmalloc
. It is based on earlier work by Doug Lea, and is maintained by Wolfram Gloger.
Doug Lea's malloc
used coarse locking (or no locking, depending on the configuration settings), where every call to malloc
/realloc
/free
is protected by a global mutex. This is safe but can be inefficient in highly multithreaded environments.
ptmalloc3
, which is the default malloc
implementation in the GNU C library (libc) used on most Linux systems these days, has a more fine-grained strategy, as described in aix's answer, which allows multiple threads to concurrently allocate memory safely.
nedmalloc
is another independent implementation which claims even better multithreaded performance than ptmalloc3
and various other allocators. I don't know how it works, and there doesn't seem to be any obvious documentation, so you'll have to check the source code to see how it works.