Are spawn'ed threads waited automatically?

[Ali Çehreli]

First, the answer may be as simple as "use core.thread.thread_joinAll". 
Is that the proper way of waiting for all threads?

Second, my question may not be a valid example as starting a thread 
without communicating with it may be under the umbrella of 
parallelization. Maybe in concurrency, threads communicate with each 
other so that the following situation should not occur in practice.

Third is my question: :) If I spawn a single thread in main, the single 
thread seems to run to completion.

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

void foo()
{
     foreach (i; 0 .. 5) {
         Thread.sleep(dur!"msecs"(500));
         writeln(i, " foo");
     }
}

void main()
{
     spawn(&foo);
     writeln("main done");
}

I get all of foo's output after "main done":

main done
0 foo
1 foo
2 foo
3 foo
4 foo

If I introduce an intermediate thread that spawns the foo thread, now 
foo sometimes terminates early:

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

void foo()
{
     foreach (i; 0 .. 5) {
         Thread.sleep(dur!"msecs"(500));
         writeln(i, " foo");
     }
}

void intermediate()
{
     spawn(&foo);
     writeln("intermediate done");
}

void main()
{
     spawn(&intermediate);
     writeln("main done");
}

The output is inconsistent. Sometimes there is nothing from foo:

main done
intermediate done

Sometimes it runs fully:

main done
intermediate done
0 foo
1 foo
2 foo
3 foo
4 foo

Is the inconsistency a bug or a natural consequence of something? :) 
(Perhaps even the first example that seems to run correctly just has a 
higher probability of showing this behavior.)

I am aware of thread_joinAll(). Is that the recommended way of waiting 
for all threads?

Thank you,
Ali