Re: Need to use "volatile" for accessing variables between threads?
On Jul 27, 9:40 am, Virchanza <virt...@lavabit.com> wrote:
Let's say I have a global variable:
int g_counter;
And let's say that this variable is accessed by two different
threads. Here's how the threads might look:
void Thread_One(void)
{
for (;;)
{
if ( !DoSomethingThatTakes15seconds() )
++g_counter;
}
}
void Thread_Two(void)
{
for (;;)
{
if ( DoSomethingThatTakes5seconds() )
--g_counter;
}
}
We need a mutex though. So the second draft would be:
void Thread_One(void)
{
for (;;)
{
if ( !DoSomething() )
{
LockMutex();
++g_counter;
UnlockMutex();
}
}
}
void Thread_Two(void)
{
for (;;)
{
if ( !DoSomething() )
{
LockMutex();
++g_counter;
UnlockMutex();
}
}
}
Finally though, I'd like to clarify one thing:
Do I need to define the g_counter as volatile?
No. The system functions ultimately called from LockMutex and
UnlockMutex subsume volatile, and make it unnecessary.
I realise that volatile is intended to be used where the value
of a variable can spontaneously change outside of the normal
flow of a program, but I don't know if this applies to
multi-threading.
It does, sort of, but... On most systems, it's not sufficient,
and once you've used the necessary synchronization requests (as
above), it's not necessary.
I'm currently writing cross-platform software which is to be
compiled for different systems such as Windows, Linux,
Solaris, Apple Mac. These different systems have different
API's for doing multi- threading, and maybe each particular
API should specify whether global variables need to be
volatile or not. (Or should it be considered something
inherent in the programming language?)
Linux, and Solaris (and the Mac, I think) use Posix threads;
Posix specifies clearly that volatile is not necessary. Windows
is a bit vaguer, but in practice, the code necessary to
make mutex (or what Windows calls CriticalSection) work will in
fact ensure that volatile is not necessary.
[...]
What's the way to go about this? I have some people telling me
there's no need for volatile at all when it comes to
multi-threading.
That's basically correct: it's absolutely correct for Posix,
it's almost certainly correct for Windows, and it's what the
upcoming version of the C++ standard (which defines threading)
will say as well.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34