I tend to use an integer rather than a boolean as your field for storing the disposed status, because then you can use the thread-safe Interlocked class to test if Dispose has already been called. Something like this: private int _disposeCount; public void Dispose() { if (Interlocked.Increment(ref _disposeCount) == 1) { // disposal code here … Read more
Barrier #2 guarentees that the write to _complete gets committed immediately. Otherwise it could remain in a queued state meaning that the read of _complete in B would not see the change caused by A even though B effectively used a volatile read. Of course, this example does not quite do justice to the problem … Read more
There are three ways in which they’re not safe: long and double aren’t even guaranteed to be updated atomically (you could see half of a write from a different thread) The memory model doesn’t guarantee that you’ll see the latest updates from one thread in another thread, without extra memory barriers of some kind The … Read more
unique_ptr is thread safe when used correctly. You broke the unwritten rule: Thou shalt never pass unique_ptr between threads by reference. The philosophy behind unique_ptr is that it has a single (unique) owner at all times. Because of that, you can always pass it safely between threads without synchronization — but you have to pass … Read more
The easiest (and correct) way is: Define a new class public class MyApp extends Application { private static MyApp instance; public static MyApp getInstance() { return instance; } public static Context getContext(){ return instance; // or return instance.getApplicationContext(); } @Override public void onCreate() { instance = this; super.onCreate(); } } Then in your manifest you … Read more
This is thread safe, right? Suppose MAXIMUM is one, count is zero, and five threads call CheckForWork. All five threads could verify that count is less than MAXIMUM. The counter would then be bumped up to five and five jobs would start. That seems contrary to the intention of the code. Moreover: the field is … Read more
You asked a very good question, allow me to expound holistically. Based on GitBub issues opened for OkHttp, my summary is this. Question I believe a single instance of OkHttpClient should be reused to create multiple connections. Is OkHttpClientthread safe? If not, isOkHttpClient.open()` thread safe? Answer Yes. It is designed to be treated as a … Read more
The locks, as you have written them are pointless. The thread reading the variable, for example, will: Acquire the lock. Read the value. Release the lock. Use the read value somehow. There is nothing to stop another thread from modifying the value after step 3. As variable access in .NET is atomic (see caveat below), … Read more
You can use Locks, RLocks, Semaphores, Conditions, Events and Queues. And this article helped me a lot. Check it out: Laurent Luce’s Blog
Let’s have a look at the relevant line: std::lock_guard<std::mutex> guard(myMutex); Notice that the lock_guard references the global mutex myMutex. That is, the same mutex for all three threads. What lock_guard does is essentially this: Upon construction, it locks myMutex and keeps a reference to it. Upon destruction (i.e. when the guard’s scope is left), it … Read more