Re^2: Shared hash within shared hash of hash???

[ISAI student]

in reply to Re: Shared hash within shared hash of hash???
in thread Shared hash within shared hash of hash???

I seem to be getting better understanding...

Two questions:

1. Do i need to use  lock $hash{foo} ;
or lock ( \%hash ) ; if foo is used as shared_clone ?

2. Can I just use

%{$hash{foo}} = () ; 

And just lock %hash, if needed?

[zwon]

I'm not sure about the first one, as for the second -- why don't you try it?

[ISAI student]

I did, it seems to work. I am however, wary of corner cases, when threads are involved.

[zwon]

I did, it seems to work

That's strange, because for me it didn't work:

use threads;
use threads::shared;

my %sa : shared = ();
%{$sa{foo}} = ();
__END__
Invalid value for shared scalar at share_share.pl line 5.

[BrowserUk]

1. Do i need to use lock $hash{foo} ; or lock ( \%hash ) ; if foo is used as shared_clone ?

It depends upon what you intend to modify.

When you have nested hashes so:

%hash :shared = &share( {} );

1. To add a new key/value pair; or delete a key/value pair; or modify the value associated with an existing key in %hash you need:

   lock %hash;
   $hash{ existingkey } = newvalue;
   # or
   $hash{ newkey } = newvalue;
   #or 
   delete $hash{ existingkey };
   

2. To modify the nested anonymous hash associated with the key 'foo', you need:

   lock %{ $hash{ foo } };
   $hash{foo}{somekey} = somevalue;
   # or
   delete $hash{ foo }{ somekey };
   

   Ie. lock %{ $h{1} } says lock the hash referenced by the value at $h{1}.

[dave_the_m]

Do i need to use lock $hash{foo} ; or lock ( \%hash ) ; if foo is used as shared_clone ?

You only need locking to ensure the consistency of your own data when shared between threads. Perl already does its own internal locking on shared structures to ensure internal consistency. So for example

my %h : shared;
$h{foo} = share ({});
...
$h{foo}{bar} = 1; # in thread 1
$h{foo}{bar} = 2; # in thread 2

Here, there is no locking, so $h{foo}{bar} may end up as 1 or 2; but it won't end up as something else; nor will the {foo} or the {bar} slots of the respective hashes get corrupted.

Dave.