All modern thread implementations can handle an uncontended mutex lock entirely in user space (with just a couple of machine instructions) – only when there is contention, the library has to call into the kernel. Another point to consider is that if an application doesn’t explicitly link to the pthread library (because it’s a single-threaded … Read more
Known problem. C++ mutexes are thin layer on top of OS-provided mutexes, and OS-provided mutexes are often not fair. They do not care for FIFO. The other side of the same coin is that threads are usually not pre-empted until they run out of their time slice. As a result, thread A in this scenario … Read more
For pthreads it will result in undefined behaviour. From the man page for pthread_mutex_unlock: Calling pthread_mutex_unlock() with a mutex that the calling thread does not hold will result in undefined behavior. Other mutexes will have their own behviour. As others have stated, it’s best to read the manual for whichever mutex you’re using.
The impl.MessageState is embedded in concrete messages only, not in the generated structs that implement a proto message. It specifically embeds the three pragmas: NoUnkeyedLiterals, DoNotCompare, and DoNotCopy. The last one, DoNotCopy is a zero-sized array of sync.Mutex. The sole purpose is to have go vet complain loudly about shallow copies, as described in the … Read more
On my machine, the following code prints out 10 times a second and consumes almost 0 cpu because most of the time the thread is either sleeping or blocked on a locked mutex: #include <chrono> #include <thread> #include <mutex> #include <iostream> using namespace std::chrono_literals; std::mutex m1; std::mutex m2; void f1() { while (true) { std::unique_lock<std::mutex> … Read more
Strings like that (from the code) could be “interned”. This means all instances of “ABC” point to the same object. Even across AppDomains you can point to the same object (thx Steven for the tip). If you have a lot of string-mutexes, from different locations, but with the same text, they could all lock on … Read more
The spinlock mutex implementation looks okay to me. I think they got the definitions of acquire and release completely wrong. Here is the clearest explanation of acquire/release consistency models that I am aware of: Gharachorloo; Lenoski; Laudon; Gibbons; Gupta; Hennessy: Memory consistency and event ordering in scalable shared-memory multiprocessors, Int’l Symp Comp Arch, ISCA(17):15-26, 1990, … Read more
“general pseudo code” is not an actual code of CAS (compare and swap) implementation. Special hardware instructions are used to activate special atomic hardware in the CPU. For example, in x86 the LOCK CMPXCHG can be used (http://en.wikipedia.org/wiki/Compare-and-swap). In gcc, for example, there is __sync_val_compare_and_swap() builtin – which implements hardware-specific atomic CAS. There is description … Read more
The motivation for these two future types goes back to move semantics, move-only types, and the new C++11 feature to return move-only types from ordinary functions. In C++98/03, if you wanted to return a type from a factory function: A make_A() { A a; // … return a; } then A had to be CopyConstructible. … Read more
As Ofir already wrote – if you try to read data from an object that some other thread is modyfying – you could get data in some inconsistent state. But – if you are sure the object is not being modified, you can of course read it from multiple threads. In general, the question you … Read more