Question

While I was learning threading memory barrier (fences) seems really not easy to understand, here in my case I want employee 10 threads simultaneously increase a Int32 number: x by 100 times at each (x++), and will get result 10 * 100 = 1000.

So this is actually an atomicity problem, and what I know so far there are a number of ways to achieve that – limited in concurrent ways:

1. Interlocked.Increment
2. exclusive lock (lock, monitor, Mutex, Semaphore, etc.)
3. ReadWriteLockSlim

If there are more better ways please kindly guide me, I tried to use a volatile read/write but failed:

for (int i = 0; i < 10000; i++)
{
    Thread.VolatileRead(ref x);
    Thread.VolatileWrite(ref x, x + 1);
}

My investigation code is tidied below:

private const int MaxThraedCount = 10;
private Thread[] m_Workers = new Thread[MaxThraedCount];
private volatile int m_Counter = 0;
private Int32 x = 0;

protected void btn_DoWork_Click(object sender, EventArgs e)
{
    for (int i = 0; i < MaxThraedCount; i++)
    {
        m_Workers[i] = new Thread(IncreaseNumber) { Name = "Thread " + (i + 1) };
        m_Workers[i].Start();
    }
}

void IncreaseNumber()
{
    try
    {
        for (int i = 0; i < 10000; i++)
            Interlocked.Increment(ref x);

        // Increases Counter and decides whether or not sets the finish signal
        m_Counter++;
        if (m_Counter == MaxThraedCount)
        {
            // Print finish information on UI
            m_Counter = 0;
        }
    }
    catch (Exception ex)
    {
        throw;
    }
}

My question is: how can I use Memory Barrier to replace Interlocked, since “All of Interlocked’s methods generate a full fence.“, I tried to modify the increase loop as below but failed, I don’t understand why…

for (int i = 0; i < 10000; i++)
{
    Thread.MemoryBarrier();
    x++;
    Thread.MemoryBarrier();
}

Answer 1

The memory barrier just keeps memory operations from moving from one side of the barrier to the other. Your issue is this:

1. Thread A reads the value of X.
2. Thread B reads the value of X.
3. Thread A adds one to the value it read.
4. Thread B adds one to the value it read.
5. Thread A writes back the value it calculated.
6. Thread B writes back the value it calculated.

Oops, two increments only added one. Memory barriers are not atomic operations and they are not locks. They just enforce ordering, not atomicity.

Unfortunately, the x86 architecture does not offer any atomic operations that don’t include a full fence. It is what it is. On the bright side, the full fence is heavily optimized. (For example, it does not ever lock any bus.)