Free-List | 有疑问或反馈，可以在 Github 发 Issue，也可以发邮件到我的 GMail，但不建议使用中国邮箱与 GMail | Email library

The answer is that there is some overhead (both in terms of per-allocation CPU cycles and in per-allocation book-keeping memory) to making many small dynamic allocations and deallocations. How much overhead will depend a lot on how your runtime's memory heap was implemented; however, most modern/popular runtimes have heap implementations that have been optimized to be quite efficient. There are some articles about how various OS's heaps are implemented that you can read about to get an idea about how they work.

In a modern heap implementation, your program probably won't "hit the wall" and grind to a halt when there are "too many" heap allocations (unless your computer actually runs out of physical RAM, of course), but it will use up proportionally more RAM and CPU cycles than a comparable program that doesn't require so many.

Given that, using a zillion tiny memory allocations is probably not the best way to go. In addition to being less than optimally efficient (since every one of those tiny allocations will require a separate block of book-keeping bytes to keep track of), lots of tiny allocations can lead to memory fragmentation problems (which are less of an issue on modern 64-bit systems with virtual memory, but still something to consider), as well as being difficult to manage correctly (it's easy to end up with memory leaks or double-frees if you are doing your allocations manually).

As others have suggested in the comments, calling new and delete explicitly is discouraged in C++; it's almost always better to use higher-level data structures (e.g. std::string, std::map, std::vector, etc, or even a proper database layer instead), since by doing it that way a lot of the difficult design work will have been done for you, saving you the pain of having to re-discover and re-solve all of the problems that others have already dealt with in the past. For example, std::string already implements the short-string-optimization that allows strings shorter than a certain number of bytes to be stored without requiring a separate heap allocation; similar to the tradeoff you are trying to make in your own designs, except you get that optimization "for free", when appropriate, simply by using std::string to store your string-data.

I found gavra0's implementation on github. With a modification by adding a free-list (using lock-free stack implementation), I got some working code.

The repository is https://github.com/buszk/ConcLinkedList. And the implementation is in this link in the dev branch.

make_shared has to allocate two things: the object being constructed and the shared_ptr's control block. To improve performance, it allocates one chunk of memory big enough for both and then placement-news them.

make_unique doesn't need to do that since a unique_ptr doesn't need a control block.

If you want to control how memory is allocated for an object to be managed by a shared_ptr, create an appropriate allocator class and use allocate_shared instead of make_shared.

Since you using php, you can use condition on the header of the page to prevent people from visiting the page unless they are redirected from a specific page. on the page they are redirecting to, then you have to use the code as stated by Abhijit

The loop continues as long as the compare-and-exchange fails, which happens if the pool head has been concurrently updated. In that case, we MUST reload the new value of "pool_" to reuse its tag...

compare_exchange_weak() writes previous value of pool_ into old_pool after each call. Documentation for compare_exchange_weak().

However, if "index" is the same as old_pool.get_index()...

This probably cannot happen, since node with that index was not moved to free list yet.