Note I tend to write lock-free code so I try to avoid any types of lock where possible. Instead I just use while(true)
loop because I have a lot of CPU power.
According to that http://msdn.microsoft.com/en-us/library/aa691278%28VS.71%29.aspx double
variable update is not atomic.
I'm concerned about two issues:
Questions:
Currently I use a lot of double
and decimal
variables/field/properties in my program and almost everythig works fine, so I really confused because I ofthen access them from different threads without any synchronization and that just works... But now I'm thinking that probably it would be better to use float
to have "built-in syncrhonization"
Synchronization variables are synchronization primitives that are used to coordinate the execution of processes based on asynchronous events. When allocated, synchronization variables serve as points upon which one or more processes can block until an event occurs. Then one or all of the processes can be unblocked.
You can have both static synchronized method and nonstatic synchronized method and synchronized blocks in Java but we can not have synchronized variable in java. Using synchronized keyword with a variable is illegal and will result in compilation error.
Yes, you need to do something. double
and decimal
are not guaranteed to be atomic, so if you don't protect it you could get a torn value - i.e. your first bullet is entirely correct.
Re volatile
; it is moot; you are not allowed to have a volatile
field that is double
or decimal
, so the simplest answer is: lock
.
Getting double
to fail is a royal PITA; but here's a torn-value example featuring decimal
(note the numbers of success/fail will change each iteration, even though the data is the same; this is the randomness of thread scheduling):
using System;
using System.Threading;
static class Program
{
private static decimal shared ;
static void Main()
{
Random random = new Random(12345);
decimal[] values = new decimal[20];
Console.WriteLine("Values:");
for (int i = 0; i < values.Length; i++)
{
values[i] = (decimal)random.NextDouble();
Console.WriteLine(values[i]);
}
Console.WriteLine();
object allAtOnce = new object();
int waiting = 10;
shared = values[0];
int correct = 0, fail = 0;
for(int i = 0 ; i < 10 ; i++)
{
Thread thread = new Thread(() =>
{
lock(allAtOnce)
{
if (Interlocked.Decrement(ref waiting) == 0)
{
Monitor.PulseAll(allAtOnce);
} else
{
Monitor.Wait(allAtOnce);
}
}
for(int j = 0 ; j < 1000 ; j++)
{
for(int k = 0 ; k < values.Length ; k++)
{
Thread.MemoryBarrier();
var tmp = shared;
if(Array.IndexOf(values, tmp) < 0)
{
Console.WriteLine("Invalid value detected: " + tmp);
Interlocked.Increment(ref fail);
} else
{
Interlocked.Increment(ref correct);
}
shared = values[k];
}
}
if (Interlocked.Increment(ref waiting) == 10)
{
Console.WriteLine("{0} correct, {1} fails",
Interlocked.CompareExchange(ref correct, 0, 0),
Interlocked.CompareExchange(ref fail, 0, 0));
Console.WriteLine("All done; press any key");
Console.ReadKey();
}
});
thread.IsBackground = false;
thread.Start();
}
}
}
The key point; the language makes no guarantees for the atomicity of double
. In reality, I expect you'll be fine, but most subtle problems caused by threading are due to using "I expect" instead of "I can guarantee".
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With