The problem is not with what you have done, but rather a variation on the following bug as noted in the BUGS section of the threads::shared POD:

share() allows you to share $hashref->{key} without giving any error message. But the $hashref->{key} is not shared, causing the error ``locking can only be used on shared values'' to occur when you attempt to lock $hashref->{key}.

What that really means is that you cannot use lock on an element of a hash or array. Both the following attempts to lock an individual element fail in the same way:

#! perl -slw
use strict;
use threads;
use threads::shared;

my %h :shared = ( x => 1 );
lock $h{ x };

my @a :shared = 1 .. 4;
lock $a[ 1 ];
[download]

The best you can do is lock the entire hash or array--with all the potential performance hit that might entail. The hit can be minimised by confining the lock to as small a scope as possible. On a single cpu, this will in most cases ensure that the lock does not get persist long enough to be interupted by a task switch and so no penalty will result. It doesn't prevent the penalty on a multi-cpu machine.

Yes. I know it is ludicrous, but no one is listening.