The storage class static allows declaring objects
which are initialized only once. If the same
line is executed a second time, the initialization
will be omitted.
Every thread will get its own
static object (TLS - thread local storage)
and won't be able to read or modify another thread's
static object - although the variable name
stays the same. Thus static allows declaring an
object that holds state that is
is global for the current thread.
This is different to
e.g. C/C++ and Java where static indeed means global
for the application, entailing synchronization issues
in multi-threaded applications.
The value assigned to a static variable must
be evaluable at compile-time. It mustn't have
runtime dependencies! It's possible to initialize
static variables at runtime using a static this()
one-time constructor for structs, classes, and modules.
static int b = 42;
// b is just intialized once!
// When run from different threads
// each b will have see its
// "own" b without interference from
// other threds.
Moreover for declaration of a "classic" global variable that
every thread can see and modify,
use the storage class __gshared which is equivalent
to C's static.
Its ugly name is a friendly reminder to use it rarely.
__gshared int b = 50;
// Also intialized just once!
// A truly global b which every thread
// can read - and making it dangerous -
// modify!