This is Thread-Safe right?

Question

Just checking... _count is being accessed safely, right?

Both methods are accessed by multiple threads.

private int _count;  public void CheckForWork() {     if (_count >= MAXIMUM) return;     Interlocked.Increment(ref _count);     Task t = Task.Run(() => Work());     t.ContinueWith(CompletedWorkHandler); }  public void CompletedWorkHandler(Task completedTask) {     Interlocked.Decrement(ref _count);     // Handle errors, etc... } 

Answer 1

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 not volatile. So what mechanism guarantees that any thread will read an up-to-date value on the no-memory-barrier path? Nothing guarantees that! You only make a memory barrier if the condition is false.

More generally: you are making a false economy here. By going with a low-lock solution you are saving the dozen nanoseconds that the uncontended lock would take. Just take the lock. You can afford the extra dozen nanoseconds.

And even more generally: do not write low-lock code unless you are an expert on processor architectures and know all optimizations that a CPU is permitted to perform on low-lock paths. You are not such an expert. I am not either. That's why I don't write low-lock code.