Question

There is global long count counter.
Thread A does

EnterCriticalSection(&crit);
// .... do something
count++;                       // (*1)
// .. do something else
LeaveCriticalSection(&crit);

Thread B does

InterlockedDecrement(&count); // (*2) not under critical secion.

At (*1), I am under a critical section. At (*2), I am not.

Is (*1) safe without InterlockedIncrement() ? (it is protected critical section).
Do I need InterlockedIncrement() at (*1) ?
I feel that I can argue both for and against.

Answer 1

You should use one or the other, not mix them.

While InterlockedDecrement is guaranteed to be atomic, operator++ is not, though in this case it likely will be depending upon your architecture. In this case, you’re not actually protecting the count variable at all.

Given that you appear to want to do simple inrecrement/decrement operations, I would suggest that you simply remove the critical section in this case and use the associated Interlocked* functions.