Threading Questions

[bitwise via Digitalmars-d-learn]

Hey, I've got a few questions if anybody's got a minute.

I'm trying to wrap my head around the threading situation in D. 
So far, things seem to be working as expected, but I want to 
verify my solutions.

1) Are the following two snippets exactly equivalent(not just in 
observable behaviour)?
a)

Mutex mut;
mut.lock();
scope(exit) mut.unlock();

b)
Mutex mut;
synchronized(mut) { }

Will 'synchronized' call 'lock' on the Mutex, or do something 
else(possibly related to the interface Object.Monitor)?

2) Phobos has 'Condition' which takes a Mutex in the constructor. 
The documentation doesn't exactly specify this, but should I 
assume it works the same as std::condition_variable in C++?

For example, is this correct?

Mutex mut;
Condition cond = new Condition(mut);

// mut must be locked before calling Condition.wait
synchronized(mut)  // depends on answer to (1)
{
     // wait() unlocks the mutex and enters wait state
     // wait() must re-acquire the mutex before returning when 
cond is signalled
     cond.wait();
}

3) Why do I have to pass a "Mutex" to "Condition"? Why can't I 
just pass an "Object"?

4) Will D's Condition ever experience spurious wakeups?

5) Why doesn't D's Condition.wait take a predicate? I assume this 
is because the answer to (4) is no.

6) Does 'shared' actually have any effect on non-global variables 
beside the syntactic regulations?

I know that all global variables are TLS unless explicitly marked 
as 'shared', but someone once told me something about 'shared' 
affecting member variables in that accessing them from a separate 
thread would return T.init instead of the actual value... or 
something like that. This seems to be wrong(thankfully).

For example, I have created this simple Worker class which seems 
to work fine without a 'shared' keyword in sight(thankfully). I'm 
wondering though, if there would be any unexpected consequences 
of doing things this way.

http://dpaste.com/2ZG2QZV




Thanks!
     Bit