c++ 共享内存缓存池

共享内存缓存池是一种常见的多进程间数据共享方案，C++也提供了相应的API来进行实现。下面是一个简单的C++共享内存缓存池的实现：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <semaphore.h>

using namespace std;

class SharedMemory
{
public:
    SharedMemory(int size)
    {
        this->size = size;

        // 打开共享内存
        fd = shm_open("/myshm", O_RDWR | O_CREAT, 0666);
        if (fd == -1)
        {
            cout << "shm_open failed" << endl;
            exit(-1);
        }

        // 调整共享内存大小
        if (ftruncate(fd, size) == -1)
        {
            cout << "ftruncate failed" << endl;
            exit(-1);
        }

        // 映射共享内存
        ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (ptr == MAP_FAILED)
        {
            cout << "mmap failed" << endl;
            exit(-1);
        }

        // 初始化信号量
        sem_init(&sem, 1, 1);
    }

    ~SharedMemory()
    {
        // 销毁信号量
        sem_destroy(&sem);

        // 解除共享内存映射
        munmap(ptr, size);

        // 关闭共享内存
        close(fd);

        // 删除共享内存
        shm_unlink("/myshm");
    }

    void* getPtr()
    {
        return ptr;
    }

    sem_t* getSem()
    {
        return &sem;
    }

private:
    int fd;
    int size;
    void* ptr;
    sem_t sem;
};

class CachePool
{
public:
    CachePool(SharedMemory& shm, int n)
    {
        this->n = n;

        // 初始化缓存池
        cache = new Cache[n];
        for (int i = 0; i < n; i++)
        {
            cache[i].used = false;
        }

        // 将缓存池指针保存在共享内存中
        memcpy(shm.getPtr(), this, sizeof(CachePool));
    }

    ~CachePool()
    {
        delete[] cache;
    }

    void* allocate()
    {
        void* ptr = NULL;

        // 获取信号量
        sem_t* sem = getSemaphore();
        sem_wait(sem);

        // 查找空闲的缓存
        for (int i = 0; i < n; i++)
        {
            if (!cache[i].used)
            {
                cache[i].used = true;
                ptr = cache[i].data;
                break;
            }
        }

        // 释放信号量
        sem_post(sem);

        return ptr;
    }

    void free(void* ptr)
    {
        // 获取信号量
        sem_t* sem = getSemaphore();
        sem_wait(sem);

        // 查找对应的缓存
        for (int i = 0; i < n; i++)
        {
            if (cache[i].data == ptr)
            {
                cache[i].used = false;
                break;
            }
        }

        // 释放信号量
        sem_post(sem);
    }

private:
    struct Cache
    {
        bool used;
        char data[1024];
    };

    int n;
    Cache* cache;

    sem_t* getSemaphore()
    {
        // 获取共享内存中的信号量指针
        SharedMemory* shm = (SharedMemory*)mmap(NULL, sizeof(SharedMemory), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        sem_t* sem = shm->getSem();
        munmap(shm, sizeof(SharedMemory));
        return sem;
    }
};

int main()
{
    // 创建共享内存
    SharedMemory shm(sizeof(CachePool));

    // 创建缓存池
    CachePool* pool = new(shm.getPtr()) CachePool(shm, 10);

    // 在缓存池中分配内存
    char* p = (char*)pool->allocate();
    strcpy(p, "hello world");
    cout << p << endl;

    // 释放内存
    pool->free(p);

    return 0;
}

以上代码实现了一个简单的共享内存缓存池，使用了C++的类和对象来封装共享内存和缓存池，并使用了信号量来实现多进程之间的同步。需要注意的是，由于共享内存和信号量是操作系统的资源，因此在使用完毕之后需要及时释放，否则可能会导致系统资源的浪费。