CODEWITHSUNDEEP
c++cmultithreadingwinapimutex
Carol Victor
Carol Victor

Reputation: 331

Stop thread from re-acquiring mutex after releasing it

I am making my own mutex to synchronize my threads and I am having the following issue:

What I have tried:

Here is how it works:

I have a structure with a state value:

volatile unsigned int state;

When I want to acquire the mutex, I check the state until it has been released (open), then acquire (close) it and break out of the infinite loop and do whatever needs to be done:

    unsigned int previous = 0;

    for (;;)
    {
        previous = InterlockedExchangeAdd(&mtx->state,
                                          0);
        if (STATE_OPEN == previous)
        {
            InterlockedExchange(&mtx->state,
                                STATE_CLOSED);

            break;
        }

        Sleep(delay);
    }

Then I simply release it for the next thread to acquire it:

InterlockedExchange(&mtx->state,
                    STATE_OPEN);

The way I am using it is I simply have one global volatile integer that I add 1 to in one thread and subtract 1 to in another one. Increasing the delay has helped with making it so that the number does not either go very low or very high and get stuck in a loop being executed in just a single thread, but a 1+ second delay is not going to work for my other purposes.

How could I go about making sure that all of the threads get a chance to acquire the mutex and not have it get stuck in a single thread?

Upvotes: 0

Views: 362

Answers (1)

MSalters
MSalters

Reputation: 179779

The mutex does exactly what it is supposed to do: it prevents multiple threads from running at the same time.

To stop a thread from re-acquiring the mutex, the basic solution is to not access the shared resource which is protected by the mutex. The thread probably should be doing something else.

You may also have a design problem. If you have multiple resources protected by a single mutex, you may have false contention between threads. if each resource had its own mutex, multiple threads could each work on their own resource.

Upvotes: 2

Related Questions