共享内存Semaphore

Semaphore 是一种用于控制共享资源访问的同步机制，它可以用于多进程或多线程的系统中。Semaphore 维护了一个计数器，表示当前可用的资源数量，当一个进程或线程需要使用该资源时，它必须首先通过 Semaphore 请求获取该资源的使用权，然后在使用完毕后释放该资源的使用权。

在共享内存中使用 Semaphore 可以实现多进程之间的同步和互斥访问。例如，假设有两个进程 A 和 B 都需要访问一个共享内存区域，它们可以通过 Semaphore 来协调它们之间的访问，保证同一时间只有一个进程可以访问该共享内存区域。

具体实现上，进程 A 和 B 在访问共享内存前都需要调用 Semaphore 的 wait 操作，如果当前计数器为 0，那么它们将被阻塞等待直到计数器变为正数；如果计数器大于 0，它们将继续执行，并将计数器减 1，表示当前有一个资源被占用。当进程 A 或 B 完成对共享内存的访问后，它们需要调用 Semaphore 的 signal 操作，将计数器加 1，表示该资源已经被释放，其他进程可以继续访问它。

Semaphore 的使用需要注意一些细节，例如在多进程环境下需要使用具有进程间共享属性的 Semaphore，还需要考虑死锁等情况，但总的来说 Semaphore 是一种非常有用的同步机制，可以帮助我们实现复杂的多进程或多线程应用程序。

相关问题

进程间通信 共享内存

进程间通信（Inter-Process Communication，简称IPC）是指在多个进程之间传递信息和共享资源的机制。其中，共享内存是一种常用的IPC方式。

共享内存是指多个进程共享同一块物理内存区域来交换数据。这样，不同的进程可以直接读写这块共享内存区域，避免了复制数据的开销和数据传输的延迟。它可以提高进程之间的通信效率。

在使用共享内存进行进程间通信时，需要先创建一个共享内存区域，并将其映射到各个进程的地址空间中。然后，进程就可以通过读写共享内存区域来进行数据交换。

为了确保多个进程对共享内存的访问安全，需要使用同步机制，比如信号量（Semaphore）或互斥锁（Mutex）。这样可以避免多个进程同时读写共享内存导致的数据混乱或冲突。

总结起来，进程间通信是多个进程之间进行信息传递和资源共享的机制，而共享内存则是其中一种常用的实现方式。通过使用共享内存，不同进程可以直接读写同一块内存区域，从而提高通信效率。

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++的类和对象来封装共享内存和缓存池，并使用了信号量来实现多进程之间的同步。需要注意的是，由于共享内存和信号量是操作系统的资源，因此在使用完毕之后需要及时释放，否则可能会导致系统资源的浪费。