Question

In multithreading (2 thread) program, I have this code:

while(-1)
{
    m.lock();

    (...)

    m.unlock();
}

m is a mutex (in my case a c++11 std::mutex, but I think it’doesn’t change if I use different library).

Assuming that the first thread owns the mutex and it’s done something in (...) part. The second thread tried to acquire the mutex, but it’s waiting that the first thread release m.

The question is: when thread 1 ends it’s (...) execution and unlocks the mutex, can we be sure that thread 2 acquires the mutex or thread 1 can re-acquire again the mutex before thread 2, leaving it stucked in lock()?

Answer 1

If both threads are equal priority, there is no such guarantee by standard mutex implementations. Some OS’s have a lis of “who’s waiting”, and will pick the “longest waiting” when you release something, but that is an implementation detail, not something you can reliably depend on.

And imagine that you have two threads, each running something like this:

m.lock();

(...)

m.unlock();
(...)    // Clearly not the same code as above (...)
m.lock();

(...)    // Some other code that needs locking against updates. 

m.unlock();

Would you want the above code to switch thread on the second lock, every time?

By the way, if both threads run with lock for the entire loop, what is the point of a lock?