Re: (forks) When do I need to lock variables?

<snip>

> In general, increment on a shared variable is not safe.  It's safe in 
> the sense that Perl won't crash.  It's _not_ save in the sense that 
> you might miss increments.  This is because shared variables in Perl 
> are implemented as tied variables, i.e. with a FETCH and STORE.  An 
> increment is this basically a FETCH, an increment and a STORE.  If 
> second thread does a FETCH before the first one has done the STORE, 
> you have lost 1 increment.

<<< I'm interested in this discussion because I'm sharing a hash across
threads (threads::shared) and it is getting updated quite frequently. 
My current assumption is that for

$hash{$index}[$array_pos] += 1;


thread 1 could write to $hash{0}[0] at the same time thread 2 writes to
$hash{1}[0] without any chance of missing an update.  Is it necessary to
lock %hash each time it is necessary to write to it?

Are these expressions handled differently?


1) $hash{$index}[$array_pos] += 1;
2) $hash{$index}[$array_pos]++;

Finally, when updating such a data structure are there efficiencies in
checking values (not committing to a write) prior to updating, eg.

$new_value = 1;

if ($hash{1}[1] == $new_value) {
	print "Don't update for identical value!\n";
}
else
	$hash{1}[1] = $new_value;
}


Best,

Moose