sem_open进程间通信

`sem_open()` 是 POSIX 标准定义的进程间通信机制之一，用于实现进程间同步和互斥。它可以创建或打开一个命名的信号量，该信号量可以被多个进程共享。

`sem_open()` 函数的原型如下：

#include <semaphore.h>

sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);

其中，`name` 是信号量名称，`oflag` 表示打开信号量的方式，`mode` 表示创建文件时的权限，`value` 表示信号量的初始值。如果 `oflag` 值为 `O_CREAT`，则 `sem_open()` 函数会创建一个新的信号量，否则会打开已存在的信号量。

使用 `sem_open()` 函数创建或打开一个信号量后，就可以使用 `sem_wait()` 和 `sem_post()` 函数来对信号量进行操作。其中，`sem_wait()` 函数会阻塞进程，直到信号量的值大于 0，然后将信号量的值减 1；`sem_post()` 函数则会将信号量的值加 1。

需要注意的是，使用 `sem_open()` 函数创建或打开的信号量在使用完后需要使用 `sem_close()` 函数关闭，并且在程序退出前需要使用 `sem_unlink()` 函数删除信号量。

相关问题

定义 sem_unlink，sem_close，sem_open，sem_post，sem_wait'代码

这些是Linux系统下的信号量操作函数，主要用于进程间的通信和同步：

1. **sem_unlink()** - 删除信号量：

   #include <semaphore.h>
   int sem_unlink(const char *sem_name);

这个函数用于从系统中移除一个已存在的信号量，通过传入的名称查找并删除对应的资源。

2. **sem_close()** - 关闭信号量描述符：

   #include <sys/sem.h>
   int sem_close(sem_t *sem);

使用一个已经打开的信号量描述符（`sem_t* sem`），关闭与该信号量相关的句柄，释放资源。

3. **sem_open()** - 打开信号量：

   #include <fcntl.h>
   int sem_open(const char *sem_name, int oflag, ...);

通过名称打开一个信号量，oflag参数可以指定操作模式，如O_CREAT用于创建新信号量，O_RDONLY用于只读等。

4. **sem_post()** - 唤醒等待信号量的进程（增加信号量计数）：

   #include <semaphore.h>
   int sem_post(sem_t *sem);

当信号量计数值大于0时，调用此函数会将计数加一，并唤醒一个等待这个信号量的进程。

5. **sem_wait()** - 等待信号量（减小信号量计数）：

   #include <semaphore.h>
   int sem_wait(sem_t *sem);

试图获取一个信号量，如果信号量的计数值为0，则进程进入阻塞状态直到其他进程调用`sem_post()`唤醒它。一旦信号量可用（计数大于0），进程将继续执行。

sem_open sem_wait实现两个进程读写共享内存的同步，包括进程1和进程2，两个信号量，一个循环

下面是使用 `sem_open()` 和 `sem_wait()` 实现两个进程读写共享内存的同步的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <semaphore.h>

#define SHM_SIZE 4096   // 共享内存大小

int main()
{
    int shm_fd;
    char *shm_ptr;
    sem_t *sem1, *sem2;

    // 创建共享内存
    shm_fd = shm_open("/shared_memory", O_CREAT | O_RDWR, 0666);
    ftruncate(shm_fd, SHM_SIZE);

    // 将共享内存映射到进程的虚拟地址空间中
    shm_ptr = (char *) mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);

    // 创建两个信号量
    sem1 = sem_open("/semaphore1", O_CREAT | O_EXCL, 0666, 0);
    sem2 = sem_open("/semaphore2", O_CREAT | O_EXCL, 0666, 1);

    if (sem1 == SEM_FAILED || sem2 == SEM_FAILED) {
        perror("Failed to create semaphore");
        exit(EXIT_FAILURE);
    }

    // 进程1读取共享内存
    if (fork() == 0) {
        for (int i = 0; i < 10; i++) {
            sem_wait(sem1);     // 等待进程2写入共享内存完成
            printf("Process 1 read from shared memory: %s\n", shm_ptr);
            sem_post(sem2);     // 通知进程2可以开始写入共享内存了
        }
        exit(EXIT_SUCCESS);
    }

    // 进程2写入共享内存
    if (fork() == 0) {
        for (int i = 0; i < 10; i++) {
            sem_wait(sem2);     // 等待进程1读取共享内存完成
            sprintf(shm_ptr, "Hello from process 2, count: %d", i);
            sem_post(sem1);     // 通知进程1可以开始读取共享内存了
        }
        exit(EXIT_SUCCESS);
    }

    // 等待子进程结束
    wait(NULL);
    wait(NULL);

    // 关闭并删除共享内存和信号量
    munmap(shm_ptr, SHM_SIZE);
    close(shm_fd);
    shm_unlink("/shared_memory");
    sem_unlink("/semaphore1");
    sem_unlink("/semaphore2");

    return 0;
}

在上面的示例代码中，进程1和进程2通过共享内存进行通信，进程1负责读取共享内存中的数据，进程2负责写入数据。为了同步两个进程的读写操作，我们使用了两个信号量 `sem1` 和 `sem2`。

进程1和进程2在读写共享内存之前都需要先等待对方完成操作，这里使用 `sem_wait()` 函数来等待信号量，如果信号量的值为 0，则该函数会一直阻塞等待，直到信号量的值大于 0。

当进程1读取共享内存完成后，它会调用 `sem_post()` 函数通知进程2可以开始写入共享内存了，此时信号量 `sem2` 的值加 1。

当进程2写入共享内存完成后，它会调用 `sem_post()` 函数通知进程1可以开始读取共享内存了，此时信号量 `sem1` 的值加 1。

这样，就能够保证进程1和进程2的读写操作互不干扰，实现了进程间的同步。