如何在c中检查信号量的状态？

我有一个全局静态变量，它是一个信号量，因为我写的是一个库，而不是一个程序

在使用库的

main（）

程序中，会调用

fork（）

，并基于共享内存在管道中读写

例如，这是使用我的库的

main（）

：

#include <stdio.h>
#include <stdlib.h>
#include "my_pipe_shared_memory_based.h"
int main()

{
    int spd, pid, rb;
    char buff[4096];
    my_new_init();

    if (my_new_fifo("tmp_shm_pipe",0666) < 0)
    {
        perror("my_new_fifo");
        exit(1);
    }

    if (fork()) 
    {
        spd = my_new_open("tmp_shm_pipe", O_RDONLY, 0600);
        if (spd < 0)
        {
            perror("PARENT: my_new_open");
            exit(1);
        }
        rb = my_new_read(spd, buff, sizeof(buff));
        if (rb > 0)
            write(1, buff, rb);
    }

    else
    {
        spd = my_new_open("tmp_shm_pipe", O_WRONLY, 0600);
        if (spd < 0)
        {
            perror("SON: my_new_open");
            exit(1);
        }
        my_new_write(spd, "hello world!\n", sizeof("hello world!\n"));
    }

    my_new_close(spd);
    my_new_un_link("tmp_shm_pipe");
    my_new_finish();

    return 0;
}

#包括
#包括
#包括“my_pipe_shared_memory_based.h”
int main（）
{
内部spd、pid、rb；
字符buff[4096]；
my_new_init（）；
如果（my_new_fifo（“tmp_shm_管道”，0666）<0）
{
佩罗（“我的新fifo”）；
出口（1）；
}
if（fork（））
{
spd=my_new_open（“tmp_shm_管道”，仅限O_RD0600）；
如果（spd<0）
{
perror（“家长：我的新开放”）；
出口（1）；
}
rb=我的新读数（spd、buff、sizeof（buff））；
如果（rb>0）
写入（1，buff，rb）；
}
其他的
{
spd=my_new_open（“tmp_shm_管道”，仅限O_WR0600）；
如果（spd<0）
{
佩罗尔（“儿子：我的新公开赛”）；
出口（1）；
}
我的新作品（spd，“你好世界！\n”，sizeof（“你好世界！\n”）；
}
my_new_close（spd）；
my_new_un_link（“tmp_shm_管道”）；
我的新饰面（）；
返回0；
}

现在，我想在每次进程在方法中读取和/或写入之前使用一个信号量：

my\u new\u write（）

my\u new\u read（）

现在，问题是，我如何在上述请求的方法中每次检查信号量的状态（例如，

my_new_write

&

my_new_read

），以便在另一个进程当前正在读/写时，我可以让该进程执行其操作，或者阻止它

谢谢

你要找的不是sem_trywait（）和sem_wait（）吗？用信号量句柄调用它们，您将知道它们的状态

不确定信号量，但带有互斥锁的pthread_cond_timedwait（）也可以让您在不阻塞线程（或给出超时）的情况下检查同步状态。

您不是在寻找sem_trywait（）和sem_wait（）吗？用信号量句柄调用它们，您将知道它们的状态

---

不确定信号量，但带有互斥锁的pthread_cond_timedwait（）也可以让您在不阻塞线程（或给出超时）的情况下检查同步状态。

这里的关键是，您必须确保确保两个进程都可以看到确保互斥的信号量。要做到这一点，您需要在分叉之前分配共享内存并初始化信号量。例如，对于此任务，您可以使用mmap。示例（无任何错误检查）：

sem_t*sem=mmap（NULL，sizeof（sem_t），
保护读取|保护写入，映射匿名|映射共享，0,0）；

在此之后，使用sem_init初始化信号量，并确保第二个参数pshared为非零。手册上说：

如果pshared为非零，则信号量在进程之间共享，并且应该位于共享内存区域（请参阅shm_open（3）、mmap（2）和shmget（2））。（由于fork（2）创建的子进程继承其父进程的内存映射，因此它也可以访问信号量。）任何可以访问共享内存区域的进程都可以使用sem_post（3）、sem_wait（3）等操作信号量

最后，分叉过程并正常使用sem_wait和sem_post

编辑：

真的，试着替换这个：

mySemaphore=sem_open（“mySemaphore”，O_CREAT，S_IRUSR | S_IWUSR）；

为此：

mySemaphore=mmap（NULL，sizeof（sem_t），
保护读取|保护写入，映射匿名|映射共享，0,0）；
sem_init（mySemaphore，1,1）；

---

在函数my_new_open

中，这里的关键是必须确保确保互斥的信号量在两个进程中都可见。要做到这一点，您需要在分叉之前分配共享内存并初始化信号量。例如，对于此任务，您可以使用mmap。示例（无任何错误检查）：

sem_t*sem=mmap（NULL，sizeof（sem_t），
保护读取|保护写入，映射匿名|映射共享，0,0）；

在此之后，使用sem_init初始化信号量，并确保第二个参数pshared为非零。手册上说：

如果pshared为非零，则信号量在进程之间共享，并且应该位于共享内存区域（请参阅shm_open（3）、mmap（2）和shmget（2））。（由于fork（2）创建的子进程继承其父进程的内存映射，因此它也可以访问信号量。）任何可以访问共享内存区域的进程都可以使用sem_post（3）、sem_wait（3）等操作信号量

最后，分叉过程并正常使用sem_wait和sem_post

编辑：

真的，试着替换这个：

mySemaphore=sem_open（“mySemaphore”，O_CREAT，S_IRUSR | S_IWUSR）；

为此：

mySemaphore=mmap（NULL，sizeof（sem_t），
保护读取|保护写入，映射匿名|映射共享，0,0）；
sem_init（mySemaphore，1,1）；

---

在函数my_new_open

Victor中，我已经尝试过了（我的意思是线程）。现在我尝试了

sem_wait

&

sem_post

，但代码仍然没有同步。有什么想法吗？我应该把代码贴出来吗？谢谢，最后，发布读/写函数，我们来看看。完成后，我发布了3种方法：

open

、

read

和

write

。谢谢。维克托，我已经尝试过了（我的意思是线程）。现在我尝试了

sem\u wait

&

sem\u post

，但代码仍然没有同步。有什么想法吗？我应该把代码贴出来吗？最后，请发布读/写函数，我们将进行查看。完成