Difference between __gshared and shared.

[via Digitalmars-d]

On Wednesday, 8 July 2015 at 14:00:43 UTC, Jonathan M Davis wrote:
> On Wednesday, 8 July 2015 at 13:26:53 UTC, Shachar Shemesh 
> wrote:
>> On 08/07/15 15:08, Jonathan M Davis wrote:
>>> I know that there are a number of people who get frustrated 
>>> with shared
>>> and using __gshared instead, but unless you fully understand 
>>> what you're
>>> doing and how the language works, and you're _really_ 
>>> careful, you're
>>> going to shoot yourself in the foot it subtle ways if you do 
>>> that.
>>>
>> I guess my main issue with this statement is that I don't see 
>> how that is not the case when using shared.
>
> Because unless you cast away shared, you're prevented from 
> doing much of anything to the object, and the compiler clearly 
> indicates which objects are shared, so the code that has to 
> worry about getting locks right and dealing with casting away 
> shared correctly is clearly marked and segregated from the rest 
> of the program, unlike with a language like C++ or Java where 
> _everything_ is shared, and you have no idea which objects are 
> actually shared across threads and which are thread-local.
>
> What we have is uglier than we'd like, but that ugliness 
> highlights the small portion of code where you actually have to 
> deal with synchronization and threading issues so that if you 
> do have a problem with it, you have a very small amount of code 
> to dig through to figure out how you screwed it up.
>
> - Jonathan M Davis

I think a good way to avoid this extra annoyance would be to have 
shared be implicitly convertible to non-shared, or actually, 
shared should just be ignored inside synchronized blocks, 
essentially the net result is that the cast is done implicitly at 
the beginning of the block.

To solve the wrong mutex problem that Dmitry mentioned, perhaps a 
declarative approach could be used? I wouldn't mind the extra 
syntax, as it also provides documentation by giving clarity into 
which mutexes guard what data. With the implicit 
stripping/ignoring of shared it would become very succinct as 
well.

```
Mutex moomtx;
Mytex cheesemtx;

shared(moomtx) int[] moo;
shared(cheesemtx) float cheese;

or perhaps with UDA:

@lock(globalmtx, moomtx) shared int moo; // either globalmtx or 
moomtx must be locked


synchronized(moomtx) {
    moomtx = []; // ok
    cheese = 1.61803f; // error: mutex moomtx is not locked, even 
though we are inside a synchronized block

    moo.sort(); // shared automatically ignored
}

// ...
moo.sort(); // error: mutex moomtx is not locked
```