I am trying to write a multithreaded program where each thread would use a counter and then increment it.
for example:
lock(this)
{
counter++;
Console.WriteLine(counter);
}
i know that for incrementation i can use:
System.Threading.Interlocked.Increment(counter);
but what about locking for both incrementing and doing something with the counter?
Thanks!
Doing this is OK:
Thread A:
var incremented_counter = Interlocked.Increment(ref counter);
Console.WriteLine(incremented_counter);
Thread B:
Interlocked.Increment(ref counter);
And doing this is OK:
Thread A:
lock (the_lock) {
++counter;
Console.WriteLine(counter);
}
Thread B:
lock (the_lock) {
++counter;
}
Doing this is OK but redundant:
Thread A:
lock (the_lock) {
var incremented_counter = Interlocked.Increment(ref counter);
Console.WriteLine(incremented_counter);
}
Thread B:
lock (the_lock) {
Interlocked.Increment(ref counter);
}
But doing this is not OK:
Thread A:
Interlocked.Increment(ref counter);
Console.WriteLine(counter);
Thread B:
Interlocked.Increment(ref counter);
Nor is it doing this:
Thread A:
lock (the_lock) {
++counter;
Console.WriteLine(counter);
}
Thread B:
Interlocked.Increment(ref counter);
Nor is it doing this:
Thread A:
var incremented_counter = Interlocked.Increment(ref counter);
Console.WriteLine(incremented_counter);
Thread B:
lock (the_lock) {
++counter;
}
(BTW, don't use lock on this.)
All of the Interlock functions return a copy of the value after modification, used that returned value during your thread.
var localCounter = System.Threading.Interlock.Increment(counter);
You will need to protect both the reading and the writing using the lock. In that case, the lock statement works best, and is easiest to follow:
private int counter;
private readonly object locker = new object();
public void IncrementCounter()
{
lock (this.locker)
{
this.counter++;
Console.WriteLine(counter);
}
}
public int GetCounter()
{
lock (this.locker)
{
return this.counter;
}
}
On the question it's a Console app, if some people will try to port over the advices here to a Windows App they may catch some surprises, especially on the lock mechanism. Just to get to my point:
object lock_obj = new object();
private async void button1_Click(object sender, EventArgs e)
{
if (Monitor.TryEnter(lock_obj))
{
int t = await Task.Run(() => getVal());
textBox1.Text = t.ToString(); ;
Monitor.Exit(lock_obj);
}
}
int count = 0;
int getVal()
{
Thread.Sleep(1000);
count++;
return count;
}
On the code above, getval will sleep for 1 second. Most people will think that Monitor.TryEnter will prevent the block of code inside the if statement being executed while getval is still in 1 sec sleep, but in fact if you press the button multiple times within 1 second, you will see the textBox1 value incrementing which may not be the intention we want based from the code. But the behavior changes if you substitute Interlocked in place of the monitor locking:
int interlockCount=0;
private async void button1_Click(object sender, EventArgs e)
{
if (Interlocked.CompareExchange(ref interlockCount, 1,0) == 0)
{
int t = await Task.Run(() => getVal());
textBox1.Text = t.ToString();
Interlocked.Exchange(ref interlockCount, 0);
}
}
You will see that the textBox1.Text will increment only by 1 even if you press the button a multiple times (while the getval is still in 1 second sleep). Effectively blocking the statements inside the if statement.
The Interlocked.Increment function both increments the counter and returns its value; the two operations are guaranteed to be atomic. Other interlocked functions exist for decrementing/reading a counter, or adding to/reading a variable. In general, one can perform almost any simple operation on an Int32 or Int64 via the pattern:
Int64 oldValue, newValue;
do
{
oldValue = theVariable;
newValue = oldValue | 1; // Sample operation
} while (Interlocked.CompareExchange(theVariable, newValue, oldValue) != oldValue);
One has to be careful to get the pattern right (e.g. be certain that newValue is computed in terms of oldValue and not theVariable) but the pattern is pretty simple and versatile.
