In C++, can new in one thread allocate the memory deleted by another thread?

Question

In glibc, malloc is implemented with arenas. So, for example, it is possible that the memory first allocated by malloc and later freed in thread A can not be used by another call of malloc in thread B, since thread A and B may be in different arenas, and different arenas maintain different heaps and free lists of memory.

When it comes to C++ (maybe also C++11 since C++11 has a new standard), is the story still the same?

Or different threads actually share the same segment of heap and free list of memory, and new in one thread can allocate the memory first newed and later deleted by another thread?

If the answer is implementation dependent, then the question is how are they implemented in the major C++ compilers, such as g++, MVC++, icc?

EDIT

I think this question is valid in the sense that sometimes you launch many threads and in each thread you dynamically allocate/deallocate a big chunk of memory for a large number of objects, and you don't want the memory usage by your application to go ridiculously high.

Answer 1

This:

different threads actually share the same segment of heap and free list of memory, and new in one thread can allocate the memory first newed and later deleted by another thread

Purpose of the threads - share memory space. If you needn't this feature, you better use processes.

Answer 2

C++ std and the allocator implementation you use are two different things.. If you use gcc to compile your C++ code, it by default uses glibc as the allocator. So if your gcc is a sufficiently newer version, it uses glibc with per-thread arenas and you are good to go.