多个线程等待相同的信号量

Question

Suppose there are 5 threads waiting for a semaphore

CreateSemaphore(sem_bridgempty,0,1,INFINITE);
WaitForSingleObject(sem_bridgempty, INFINITE);

Now when sem_bridgeempty is signalled, one of the 5 threads will wake up and rest will again wait for sem_bridgeempty to be signalled.Am i right here?

I am implementing one lane bridge problem where there can be vehicles moving from one direction only at a time.Also the capacity of the bridge is fixed at 5.What i have done so far is

unsigned WINAPI enter(void *param)
{
    int direction = *((int *)param);
    while (1)
    {
        WaitForSingleObject(sem_bridgecount, INFINITE);
        WaitForSingleObject(mut_mutex, INFINITE);
        if (curr_direction == -1 || direction == curr_direction)
        {
            curr_direction = direction;
            cars_count++;
            std::cout << "Car with direction " << direction << " entered " << GetCurrentThreadId() << std::endl;
            ReleaseMutex(mut_mutex);
            break;
        }
        else
        {
            ReleaseMutex(mut_mutex);
            WaitForSingleObject(sem_bridgempty, INFINITE);
        }
    }
    Sleep(5000);
    exit1(NULL);
    return 0;
}

 unsigned WINAPI exit1(void *param)
{   
    WaitForSingleObject(mut_mutex, INFINITE);

    cars_count--;
    std::cout << "A Car exited " << GetCurrentThreadId() << std::endl;
    ReleaseSemaphore(sem_bridgecount, 1, NULL);
    if (cars_count == 0)
    {
        curr_direction = -1;
        std::cout << "Bridge is empty " << GetCurrentThreadId() << std::endl;
        ReleaseSemaphore(sem_bridgempty, 1, NULL);
    }
    ReleaseMutex(mut_mutex);
    return 0;
}

int main()
{
    sem_bridgecount = CreateSemaphore(NULL, 5, 5, NULL);
    sem_bridgempty = CreateSemaphore(NULL, 0, 1, NULL); 
    mut_mutex = CreateMutex(NULL, false, NULL);
    //create threads here
}

Consider the below portion

    else
    {
        ReleaseMutex(mut_mutex);
        WaitForSingleObject(sem_bridgempty, INFINITE);

A car is going in direction 1.Now there are three enter requests with direction 2.All 3 will be blocked at WaitForSingleObject(sem_bridgempty, INFINITE); .Now when the bridge goes empty.One of the three will be picked up.The one picked up will again make bridge non empty.Then the other two will still wait for the bridge to go empty even though the direction is same. So even though there is direction=2 car on the bridge, other cars with the same direction are still waiting for the sem_bridgempty . I even thought of using sem_bridgempty as an event instead of semaphore (setevent() in exit1() when cars_count=0 and resetevent() in enter() when first car enters).But still all threads don't wake up.

Answer 1

The cleanest option would be to use a critical section and a condition variable.

The ENTER algorithm would look like this:

• Claim the critical section.
• Call SleepConditionVariableCS in a loop, as shown in Using Condition Variables , until either:
  • The traffic is going in the right direction and the bridge has capacity left, or
  • The bridge is empty.
• Update the state to represent your car entering the bridge.
• Release the critical section.

The EXIT algorithm would look like this:

• Claim the critical section.
• Update the state to represent your car leaving the bridge.
• Release the critical section.
• Call WakeConditionVariable.

The condition variable could be an integer whose magnitude represents the number of cars on the bridge and whose sign represents the direction of travel.

---

If you wanted to avoid condition variables, the simplest solution I could come up with requires one critical section and three auto-reset events: one for each direction of travel, plus one to indicate that the bridge is empty. You will also need a variable representing the number of cars on the bridge.

The ENTER algorithm would look like this:

• Using WaitForMultipleObjects, claim the event corresponding to your direction of travel or the event corresponding to the bridge being empty, whichever is available first.
• Enter the critical section.
• Increment the count to represent your car entering the bridge.
• If the count is not at capacity, set the event representing your direction of travel.
• Leave the critical section.

The EXIT algorithm would look like this:

• Enter the critical section.
• Decrement the count to represent your car leaving the bridge.
• If the count is zero, set the event indicating that the bridge is empty.
• If the count is nonzero, set the event corresponding to your direction of travel.
• Release the critical section.

Answer 2

need create objects which most corresponded to task. in current task - we have 2 queues - on both direction. both this queue is FIFO by sense. and we need have ability wake exactly count of entries in queue - not only one or all. the windows semaphore is exactly correspond to this. this is FIFO queue and by call ReleaseSemaphore we can exactly set amount of threads (entries) to wake - this is second parameter of api lReleaseCount . in case event or ConditionVariable we can only wake single or all waiters.

your mistake not in that you select semaphore - this is the best choice for this task. you mistake that you select it for wrong essences - sem_bridgecount, sem_bridgempty - which is not queue by sence at all. you ned have 2 semaphores for 2 directions - HANDLE _hSemaphore[2]; - one semaphore per direction - create it as _hSemaphore[0] = CreateSemaphore(0, 0, MAXLONG, 0) - initial count is 0 (!) and maximum count is unlimited (but can select any value >= 5). when car try enter to bridge in direction and can not, because now another direction is active or no free space on bridge - it must wait on semaphore (in FIFO queue) _hSemaphore[direction] . and when car exit from bridge - he need check current situation on bridge and wake one or another direction on some exactly cars count ( n ) (not all or single) - so call ReleaseSemaphore(_hSemaphore[direction], n, 0);

in general:

void enter(int direction)
{
  EnterCriticalSection(..);
  BOOL IsNeedWait = fn(direction);
  LeaveCriticalSection(..);
  if (IsNeedWait) WaitForSingleObject(_hSemaphore[direction], INFINITE)
}

and

void exit(int direction)
{
  EnterCriticalSection(..);
  direction = calc_new(direction);
  if (int WakeCount = calc_wake_count(direction))
  {
    ReleaseSemaphore(_hSemaphore[direction], WakeCount, 0);
  }
  LeaveCriticalSection(..);
}

note that in every enter - car only once enter to CriticalSection and after wait on _hSemaphore[direction] it just enter to bridge without again enter to cs and check conditions. this is because we can calculate exactly cars count (not single or all) and direction in exit - and wake only cars which and must enter to bridge, this will be impossible if use events or conditional variables

despite solution with conditional variables and CS is possible, i think it not best because: thread after wait in SleepConditionVariableCS - again enter to cs which is absolute not need we need or wake only single car by WakeConditionVariable when really can multiple cars enter to bridge, or wake all by WakeAllConditionVariable but in this case several threads in concurrent again try enter to the same cs and only one will be winner, another will be wait here count of waiting threads can be more than maximum place on bridge (5 in your case) - and some threads will be need begin wait again in loop. all this can be avoid if correct use semaphore

full working implementation here