shared Mutex?

[tcak via Digitalmars-d-learn]

On Thursday, 9 June 2016 at 18:31:16 UTC, cy wrote:
> I was thinking of using threads in a D program (ignores 
> unearthly wailing) and I need 1 thread for each unique string 
> resource (database connection info). So I did this:
>
> shared BackgroundDB[string] back;
>
> I don't see any way to make less data shared there. If it 
> weren't shared, it would be thread local, and two application 
> threads trying to look up the same database would end up firing 
> off two BackgroundDB threads, since they had separate copies of 
> "back" that could not share keys. So it pretty much has to be 
> shared. But that means freaking /everything/ has to be shared.
>
> In the dedicated thread, I had it repeatedly waiting on a 
> condition, and once that condition is signaled, it removes 
> what's been queued up, and processes those queued items in the 
> database. Except for one problem... conditions can't be shared.
>
>> Error: non-shared method core.sync.condition.Condition.mutex 
>> is not callable using a shared object
>
> Obviously you shouldn't need mutexes if you're using shared... 
> but how do you do conditions, then?
>
> When I do something like this:
>
> struct BackgroundDB {
>   Condition stuff_ready;
>   ...
> }
>
> Condition is implicitly converted to shared(Condition) when I 
> create a shared(BackgroundDB), and BackgroundDB is implicitly 
> converted to shared(BackgroundDB) when I have a shared 
> BackgroundDB[string]. But shared(Condition) then has a 
> shared(Mutex) inside it, and that can't be locked, since 
> Mutex.lock is a non-shared function.
>
> Is core.sync.mutex.Mutex even usable in D anymore? It seems 
> every mutex that wasn't shared would be part of thread local 
> data, so two threads locking on the same mutex would actually 
> be locking separate mutexes.

Mutex, Condition, and Thread classes should be defined as shared 
as you experience, but they are not unfortunately. What you need 
to do is the define them as shared, and while calling their 
method, remove shared from them. Example is below:

class MyClass{
     private core.sync.mutex.Mutex mx;

     public this() shared{
         mx = cast(shared)( new core.sync.mutex.Mutex() );

         (cast()mx).lock();

         ... etc.
     }
}