Thread usage cases

1. Scalars

	Thread1		Thread2
	$a = 1;		$a = 2;

$a is set to 1 and then 2, or 2 and then 1. It just depends which
thread gets there first.


2. Arrays

	Thread1			Thread2
	push @a, (1, 2, 3);	push @a, (4, 5, 6);

The interesting question is whether push is atomic.

Atomic
@a is either (1, 2, 3, 4, 5, 6) or (4, 5, 6, 1, 2, 3)

Non-atomic
@a could be (1, 4, 2, 5, 3, 6)

Users can probably live with either; the hard problems are
implementation under SMP. If push is atomic, then we lock out one
processor for a potentially long time while the other processor
executes the push. If push isn't atomic, then we enter and leave a
critical section once for each element that is pushed.


3. Subroutines

	sub foo { print "foo" }

	Thread1		Thread2
	foo();		eval 'sub foo { print "bar" }';

This prints either "foo" or "bar". 

Thread2 replaces the coderef for &main::foo. This could happen *while*
Thread1 is executing foo(). We can handle this by having Thread1 hold
a reference count on the coderef while it is executing foo().


4. Regular expressions

	Thread1			Thread2
	$a =~ /.../		$a = 'foo';

It seems like an RE match should be atomic, because it hard to imagine
it executing sensibly if the target string changes during the match.
But then we have

	$a =~ s/.../.../e;	$a = 'foo';

s///e can execute arbitrary code, so if s// is atomic, then Thread2
could be blocked for an arbitrary length of time.


- SWM