shared usage in d

原文
永远不要使用__gshared.This is a clear security hole.改为使用shared.
If encountered when usingshared的编译错误,那是编译器warning you.Should be serious考虑线程安全,Then just drop it in the right placeshared.
使用__gshared,The compiler pretends not to see it变量是共享的.And unless you think carefully,Guaranteed to generate竞争.

顺便,有优先__gshared而非shared的情况吗?It seems that many newbies are using it__gshared.

我不完全Agree with that,It just depends on your usage.一般,你应该使用shared,但__gshared有意义.只是在多线程It only has a problem if it can be changed,But if it's only from单线程Change but from多线程读取,is generally not a problem.
总之:
单写/单读?用__gshared
单写/多读?用__gshared
多写/单读?用shared
多写/多读?用shared

如果与C对接,则需要__gshared.但是,是的,这里应该使用shared.

__gshared表现不错,But I use it firststd.concurrency,示例:

import std.stdio;
import std.concurrency;
import core.thread;

struct Result {
    
  int value;
}

struct Done {
    
}

void run()
{
    
  bool done = false;
  while (!done) {
    
    writeln("运行子线程");
    receiveTimeout(1.seconds,
        (Done msg) {
    
            done = true;
        });
  }

  // `发送`Result to owner
  // 假定,Threads produce results in the above loop
  ownerTid.send(Result(42));
}

void main()
{
    
    auto worker = spawn(&run);
    Thread.sleep(5.seconds);
    worker.send(Done());
    auto result = receiveOnly!Result();
    writeln("结果:", result);
}

所有这些都可能是竞争条件.
这是Write and read的:

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安全地访问变量,则可用shared.我坚持:永远不要使用__gshared.
A quick test showsextern(C) extern shared工作很好.
据我所知,__gshared仅在,你想在单线程程序中访问共享C变量Works well.然后,if used later多线程,你仍然会失败.
所以,永远不要(在多线程代码中)使用__gshared.

C没有共享概念,So not correct类型.加上shared只是假,and cause trouble.最好明确说明.
Not that you should use it freely__gshared,或只在D中使用.而是说Never should使用它,这是错误的.

废话.Add to the shared variableshared不是"说谎".CIt doesn't matter if you differentiate.但D重要.

if you can identify it__gshared的有效用例,并用它编写正确代码,then you will know什么don't listen to me.
其他人,永远不要使用__gshared.
__gshared和-boundscheck=off一样糟糕.They are all obvious安全漏洞.

auto x=s.x;

Here is your problem,not because it is__gshared.
You copied the value,Obviously it can be changed at the same time,这是常识.
You should not use it this way.Instead, it should be accessed directlys.x.
而用共享,如果读取线程lock first,则结果相同,且在更改前The value is read and processed.

读x时,就改了x.

auto x = s.x;
assert(s.x == 0 || s.x == -1, to!string(s.x, 16));
//Multiple competing alternatives to the original1a competition,and cannot locate the problem

sharedIt doesn't solve the conditional race,这是对的.如果没有-preview=nosharedaccess,There is no difference.所以不妨使用shared.
但是有了-preview=nosharedaccess,The code no longer compiles,你不得不考虑如何安全访问共享数据.哪个好?
所以:永远不要使用__gshared,总是用-preview=nosharedaccess.

如果你有更好Abstract and careful锁定访问数据,但C不行,如果想访问C全局变量,应使用__gshared,Because that's what it is用途.使用shared,帮不了你.
使用__gshared来共享数据给C,与使用-boundscheck=onSend arrays to no such restrictionsC中一样安全.
这里结论Really should be,不要使用C.

不,使用sharedcan really help you.
C没有shared限定符,但C程序员still have to be considered线程安全.调用C函数或访问C全局变量必须考虑多线程.shared加上(-preview=nosharedaccess)force you to think合同是什么.__gshared没有.

不,这不对.C总是不安全的,这是正确的,但不重要.The point is that you are thereD端可以/不能做什么.

-boundscheck=on,not easilyD端搞砸.CThe end can still be messy.
-boundscheck=off,很容易在Dend fucked.
shared,not easilyDend fucked.CThe end can still be messy.
__gshared,很容易在D端搞砸.

shared让你感觉该语言Help you prevent problems.同样,对C,这是假的.

边界在C和D中的定义相同,有指针和大小,You cannot exceed that size.是的,Data is communicated in different ways,But it's easy to understand and use.
shared(加上-preview=nosharedaccess),阻止You play.No foul.Can't hurt自己.可通过强制转换告诉编译器(1)Are you sure you want to play,及(2),你将按CPlay with the rules of the end.
__gsharedJust keep you in球场上奔跑.I don't know the rules?The compiler doesn't care.玩得开心Break your leg.
用__gshared:

extern(C) extern __gshared int x;
void fun() {
     x = 42; }
//编译,条件竞争

我甚至Didn't notice I was doing it危险事情,因为第一次天真which compiles and seems to pass工作正常.
使用shared(加-preview=nosharedaccess):

extern(C) extern shared int x;
void fun() {
     x = 42; } /* 错误 */

If you look at the documentation,会发现关于正确用法.正如你所建议的,我想出了:

extern(C) extern shared int x;
void fun() {
     properlyUse(&x, 42); }
//仍错误,但共享.

I am forced更多consider线程安全.It can be discarded hereshared,Because the call is thread-safeproperlyUse函数.所以:

extern(C) extern shared int x;
void fun() {
     properlyUse(cast(int*) &x, 42); }
//编译,正确.

用__gsharedThis is unlikely to happen.没有转换的调用properlyUse可能更好,But I don't trust people记得在没有编译器对他们大喊大叫use this function.

Even if they do it right the first time,随着时间推移,They will also fail.当简单的,错误的代码编译时,It will definitely go in源文件.
It's hard to get it right线程安全.需要从编译器All help obtained.__gsharedProvides zero help.shared至少高亮interesting place.