写一个C++内存池符合高效，多并发

好的。首先，为了让内存池更高效，你可以使用一个链表来维护内存块的使用情况，这样就可以快速找到空闲的内存块并分配给新的请求。

为了支持多并发，你可以使用互斥锁来保护内存池的数据结构，这样就可以避免多个线程同时访问内存池造成的冲突。

下面是一个简单的内存池的实现：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define POOL_SIZE 1000000

typedef struct block {
    size_t size;
    struct block *next;
} Block;

typedef struct memory_pool {
    Block *free_list;
    pthread_mutex_t lock;
} MemoryPool;

MemoryPool *pool;

void *allocate(size_t size) {
    void *ptr = NULL;
    pthread_mutex_lock(&pool->lock);
    Block *curr = pool->free_list;
    Block *prev = NULL;
    while (curr != NULL) {
        if (curr->size >= size) {
            ptr = curr + 1;
            if (curr->size > size + sizeof(Block)) {
                Block *new_block = (Block *)((char *)ptr + size);
                new_block->size = curr->size - size - sizeof(Block);
                new_block->next = curr->next;
                curr->size = size;
                curr->next = new_block;
            } else {
                if (prev != NULL) {
                    prev->next = curr->next;
                } else {
                    pool->free_list = curr->next;
                }
            }
            break;
        }
        prev = curr;
        curr = curr->next;
    }
    pthread_mutex_unlock(&pool->lock);
    return ptr;
}

void deallocate(void *ptr) {
    Block *block = (Block *)ptr - 1;
    pthread_mutex_lock(&pool->lock);
    block->next = pool->free_list;
    pool->free_list = block;
    pthread_mutex_unlock(&pool->lock);
}

void initialize_memory_pool() {
    pool = malloc(sizeof(MemoryPool));
    pthread_mutex