这个锁+ ManualResetEvent使用线程安全吗？

Question

This is a separate question based off of this question . To recap, say I have two functions that manipulate a count, and an OnTimer function that fires at a regular interval. My desire is that if/when OverwriteCount is called, IncrementCount can't be executed until the timer function executes.

The proposed solution was:

private int _myCount = 0;
private readonly object _sync = new object();
private ManualResetEventSlim mre = new ManualResetEventSlim(initialState: true);

void IncrementCount()
{
    mre.Wait(); // all threads wait until the event is signaled

    lock (_sync)
    {
        _myCount++;
    }
}

void OverwriteCount(int newValue)
{
    lock (_sync)
    {
        mre.Reset(); // unsignal the event, blocking threads
        _myCount = newValue;
    }
}

void OnTimer()
{
    lock (_sync)
    {
        Console.WriteLine(_myCount);
        mre.Set(); // signal the event
    }
}

The ManualResetEventSlim tries to ensure that once OverwriteCount() unsignals the event, any modifications to _myCount must wait until OnTimer() executes.

Problem :

1. Say thread A enters IncrementCount() and passes the event's wait() - the ManualResetEvent's initial state is already signaled.
2. Thread B then starts and executes all of OverwriteCount().
3. Thread A then continues by acquiring the lock and incrementing _myCount.

This violates my goal as _myCount would change after a call to OverwriteCount(), prior to OnTimer running.

Rejected Alternative : I could move mre.Wait() within lock(_sync) but that poses a deadlock risk. If thread A calls IncrementCount() and blocks on the wait, no other threads can acquire the lock to release it.

Question : Do I need a different synchronization primitive to achieve my goal? Alternatively, am I wrong about the thread safety concern?

Answer 1

I think you can achieve your goal with just the standard Monitor and an additional flag.

private readonly object _sync = new object();
private int _myCount = 0;
private bool _canIncrement = true;

void IncrementCount()
{
    lock (_sync)
    {
        // If the flag indicates we can't increment, unlock _sync and wait for a pulse.
        // Use a loop here to ensure that if Wait() returns following the PulseAll() below
        // (after re-acquiring the lock on _sync), but a call to OverwriteCount managed to
        // occur in-between, that we wait again.
        while (!_canIncrement)
        {
            Monitor.Wait(_sync);
        }

        _myCount++;
    }
}

void OverwriteCount(int newValue)
{
    lock (_sync)
    {
        _canIncrement = false;
        _myCount = newValue;
    }
}

void OnTimer()
{
    lock (_sync)
    {
        Console.WriteLine(_myCount);
        _canIncrement = true;
        // Ready any threads waiting on _sync in IncrementCount() above
        Monitor.PulseAll(_sync);
    }
}