Is it possible to use mutex in multiprocessing case on Linux/UNIX ?

by

Mutual exclusion locks (mutexes) prevent multiple threads
from simultaneously executing critical sections of code that
access shared data (that is, mutexes are used to serialize
the execution of threads). All mutexes must be global. A
successful call for a mutex lock by way of mutex_lock()
will cause another thread that is also trying to lock the
same mutex to block until the owner thread unlocks it by way
of mutex_unlock(). Threads within the same process or
within other processes can share mutexes.

Mutexes can synchronize threads within the same process or
in other processes. Mutexes can be used to synchronize
threads between processes if the mutexes are allocated in
writable memory and shared among the cooperating processes
(see mmap(2)), and have been initialized for this task.

Initialization

Mutexes are either intra-process or inter-process, depending
upon the argument passed implicitly or explicitly to the
initialization of that mutex. A statically allocated mutex
does not need to be explicitly initialized; by default, a
statically allocated mutex is initialized with all zeros
and its scope is set to be within the calling process.

For inter-process synchronization, a mutex needs to be allo-
cated in memory shared between these processes. Since the
memory for such a mutex must be allocated dynamically, the
mutex needs to be explicitly initialized using mutex_init().

More Related Contents:

  1. When should we use mutex and when should we use semaphore
  2. Conditional Variable vs Semaphore
  3. When is a condition variable needed, isn’t a mutex enough?
  4. What is a mutex?
  5. Recursive Lock (Mutex) vs Non-Recursive Lock (Mutex)
  6. What is a semaphore?
  7. Mutex example / tutorial? [closed]
  8. What is mutex and semaphore in Java ? What is the main difference?
  9. How efficient is locking an unlocked mutex? What is the cost of a mutex?
  10. What are the differences between various threading synchronization options in C#?
  11. Doxygen is Slow
  12. Using string as a lock to do thread synchronization
  13. How efficient is locking and unlocked mutex? What is the cost of a mutex?
  14. Can a hyper-threaded processor core execute two threads at the exact same time?
  15. How do I run parallel threads of computation on a partitioned array?
  16. ReleaseSemaphore does not release the semaphore
  17. Which is more efficient, basic mutex lock or atomic integer?
  18. Do lock-free algorithms really perform better than their lock-full counterparts?
  19. Multiprocessing vs Threading Python [duplicate]
  20. Avoid synchronized(this) in Java?
  21. Is multi-thread output from System.out.println interleaved
  22. what is the correct way to implement a QThread… (example please…)
  23. CoreData: warning: Unable to load class named
  24. How to cancel Future in Scala?
  25. What is a “thread” (really)?
  26. How, if at all, do Erlang Processes map to Kernel Threads?
  27. Thread references require static lifetime?
  28. SynchronizationLockException on Monitor.Exit when using await
  29. What happens when different CPU cores write to the same RAM address without synchronization?
  30. How to implement a Lock with a timeout in Python 2.7

Leave a Comment