shared Mutex?

[cy via Digitalmars-d-learn]

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.