使用POSIX计数信号量作为二进制信号量

Question

I am trying to use POSIX counting semaphore as a binary semaphore ?

For the purpose, I have written the following code

sem = sem_open(argv[optind], flags, perms, 1); // Initialising semaphore to 1

    while(sem_getvalue(sem) > 0)
    {
    continue;

    }
    sem_post(sem);

Are there any other methods to use a counting semaphore as a binary semaphore? Here if the comtext switching occurs immediately after the while lopp is evalauted to false, and yet sem_post hasn't been called, in such a situation wouldn't that leads to race condition? Is there any other better soultions, for what I am trying to achieve.

I have multiple processes being synchronized with the sempahore. I am aware this code does not let gurantee a scenario, when during sem_getvalue even if the sem value becomes zero, even before sem_post in a particular process is called, anotehr process may also call sem_post, leading the value to be 2. How such a scenario can be resolved.

My problem won't be solved by a mutex, as in my problem, there are processes that is used only for the signal ie sem_post operation, unlike in mutex, where all the processes will have wait and signal continually

Answer 1

There are some issues with the code you posted.

while(sem_getvalue(sem) > 0)

This is referred to as busy waiting, which means the process spins on the semaphore and doesn't relinquish the CPU to the scheduler. Typically, busy waiting is only done in the scenario where the wait should be less than the time for context switching (eg low latency).

The next issue is that your semantics are inverted. You decrement and proceed when the semaphore is greater than 0. Additionally, your calls are not atomic which introduces a number of race conditions.

Effectively, you need mutex semantics since there are only two states (0/locked and 1/unlocked). For this, you can either guarantee that a sem_post never proceeds a sem_wait , or you can use a file lock.

const char* lock_file = ".lock";

const int fd_lock = open(lock_file, O_CREAT);

flock(fd_lock, LOCK_EX);

// do stuff

flock(fd_lock, LOCK_UN);

// do more stuff

close(fd_lock);    
unlink(lock_file);

The POSIX variant would involve fcntl instead of flock .