How to give priority to privileged thread in mutex locking?

by

I can think of three methods using only threading primitives:

Triple mutex

Three mutexes would work here:

  • data mutex (‘M’)
  • next-to-access mutex (‘N’), and
  • low-priority access mutex (‘L’)

Access patterns are:

  • Low-priority threads: lock L, lock N, lock M, unlock N, { do stuff }, unlock M, unlock L
  • High-priority thread: lock N, lock M, unlock N, { do stuff }, unlock M

That way the access to the data is protected, and the high-priority thread can get ahead of the low-priority threads in access to it.

Mutex, condition variable, atomic flag

The primitive way to do this is with a condition variable and an atomic:

  • Mutex M;
  • Condvar C;
  • atomic bool hpt_waiting;

Data access patterns:

  • Low-priority thread: lock M, while (hpt_waiting) wait C on M, { do stuff }, broadcast C, unlock M
  • High-priority thread: hpt_waiting := true, lock M, hpt_waiting := false, { do stuff }, broadcast C, unlock M

Mutex, condition variable, two non-atomic flag

Alternatively you can use two non-atomic bools with a condvar; in this technique the mutex/condvar protects the flags, and the data is protected not by a mutex but by a flag:

  • Mutex M;

  • Condvar C;

  • bool data_held, hpt_waiting;

  • Low-priority thread: lock M, while (hpt_waiting or data_held) wait C on M, data_held := true, unlock M, { do stuff }, lock M, data_held := false, broadcast C, unlock M

  • High-priority thread: lock M, hpt_waiting := true, while (data_held) wait C on M, data_held := true, unlock M, { do stuff }, lock M, data_held := false, hpt_waiting := false, broadcast C, unlock M

More Related Contents:

  1. How can I use something like std::vector?
  2. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  3. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  4. Concurrency: Atomic and volatile in C++11 memory model
  5. Example for boost shared_mutex (multiple reads/one write)?
  6. What happens to a detached thread when main() exits?
  7. What are the correct link options to use std::thread in GCC under linux?
  8. Why is the destructor of a future returned from `std::async` blocking?
  9. understanding of pthread_cond_wait() and pthread_cond_signal()
  10. Does MinGW-w64 support std::thread out of the box when using the Win32 threading model?
  11. C++11 thread-safe queue
  12. How to implement multithread safe singleton in C++11 without using
  13. Difference between pointer and reference as thread parameter
  14. Does the C++ volatile keyword introduce a memory fence?
  15. Which std::async implementations use thread pools?
  16. Get the status of a std::future
  17. Delayed start of a thread in C++ 11
  18. What is std::promise?
  19. C++11 STL containers and thread safety
  20. Can I use std::async without waiting for the future limitation?
  21. Passing arguments to std::async by reference fails
  22. C++11 equivalent to boost shared_mutex
  23. C++ terminate called without an active exception
  24. When to use recursive mutex?
  25. C++11 std::threads vs posix threads
  26. Understanding std::atomic::compare_exchange_weak() in C++11
  27. GCC std::thread not found in namespace std
  28. std::thread calling method of class [duplicate]
  29. Write concurrently vector
  30. Why does this simple std::thread example not work?

Leave a Comment