On 8/7/22 9:36 PM, vc wrote:

is zeus declared just as:

bool zeus;

Because if so, it is in thread local storage. This is different per thread. This means, each thread gets its own copy, and writing to the copy in one thread doesn't affect any other threads.

Note that Emanuele is also right that you have a race condition in any case. So you likely have 2 problems going on.

-Steve

On Monday, 8 August 2022 at 02:49:06 UTC, Steven Schveighoffer wrote:

bool zeus;

yes it is declared as

bool zeus;

it seems change it to working is working

 __gshared bool zeus;

but as I'm new in to D, i will like to hear thoughts even if it works for me

On Monday, 8 August 2022 at 07:14:33 UTC, vc wrote:

 __gshared bool zeus;

Never ever use __gshared ever. It's a glaring safety hole. Use shared instead.

If you're running into compilation errors with shared, that's the compiler trying to keep you from shooting your foot off. You're supposed to think hard about thread-safety and only then cast shared away in the right spot.

With __gshared, the compiler just pretends that it doesn't see that the variable is shared. You're pretty much guaranteed to produce race conditions unless you think even harder than you would have with shared.

By the way, is there some resource that recommends __gshared over shared? It seems that many newbies reach for __gshared first for some reason.

On Monday, 8 August 2022 at 10:17:57 UTC, ag0aep6g wrote:

I don't agree with this entirely, it just depends on how you use it. In general you should go with shared, but __gshared does have its places. It's only problematic when it can be changed from multiple threads, but if it's only changed from a single thread but read from many then it generally isn't a problem.

To sum it up:

Single-write/Single-read?
__gshared

Single-write/Multi-read?
__gshared

Multi-write/Single-read?
shared

Multi-write/Multi-read?
shared

On 8/8/22 6:17 AM, ag0aep6g wrote:

 __gshared bool zeus;
 ```

but as I'm new in to D, i will like to hear thoughts even if it works for me

If you are interfacing with C, you need __gshared. But yeah, you should use shared in this case.

-Steve

On Monday, 8 August 2022 at 12:45:20 UTC, bauss wrote:

Nope. All of those can be race conditions.

Here's a single-write, single-read one:

align(64) static struct S
{
    align(1):
    ubyte[60] off;
    ulong x = 0;
}
__gshared S s;
void main()
{
    import core.thread: Thread;
    import std.conv: to;
    new Thread(() {
        foreach (i; 0 .. uint.max)
        {
            s.x = 0;
            s.x = -1;
        }
    }).start();
    foreach (i; 0 .. uint.max)
    {
        auto x = s.x;
        assert(x == 0 || x == -1, to!string(x, 16));
    }
}

If you know how to access the variable safely, you can do it with shared.

I maintain: Never ever use __gshared ever.

On Monday, 8 August 2022 at 10:17:57 UTC, ag0aep6g wrote:

Would be also good if the specs would tell more about those "guards":

The only thing I see is that the compiler bails about type incompatibilities but how does it help in case of synchronization/locking issues?