#!/usr/bin/perl

use warnings;
use strict;
use threads;
use threads::shared;
use Data::Dumper;

my $href = &share({});
$href = {};

sub sub1 {
  sleep 1;
  print threads->tid();
  print Dumper $href;
}

$href->{a} = &share({});
$href->{a} = {};

my $th1 = threads->new('sub1');
$href->{b} = &share({});
my $th2 = threads->new('sub1');

$th1->join();
$th2->join();
[download]

1$VAR1 = {
          'a' => {}
        };
2$VAR1 = {
          'a' => {},
          'b' => {}
        };
[download]

Why do you assign a nicely shared anonymous hash my $href = &share({});, and then immmediately overwrite it with a non-shared one: $href = {};?

What you are doing is assigning a reference to a shared anonymous hash, to a non-shared scalar. You then immediately overwrite it with a reference to a non-shared anonynous hash.

And you do a similar thing again here:

$href->{a} = &share({});
$href->{a} = {};
[download]

It's kind of very surprising to me that anything gets shared this way(*), but if simply remove that bewildering practice, then you'll get something approaching the effect you are looking for:

#!/usr/bin/perl 

use warnings;
use strict;
use threads;
use threads::shared;
use Data::Dumper;

my $href = &share({});
#$href = {};

sub sub1 {
  sleep 1;
  print threads->tid();
  print Dumper $href;
}

$href->{a} = &share({});
#$href->{a} = {};

my $th1 = threads->new('sub1');
$href->{b} = &share({});
my $th2 = threads->new('sub1');

$th1->join();
$th2->join();
__OUTPUTS_
C:\test>junk1
1$VAR1 = {
          'a' => {},
          'b' => {}
        };

2$VAR1 = {
          'a' => {},
          'b' => {}
        };
[download]

That said, I don't understand why you are doing things the way you are doing them. But I realise this is just a snippet, so it might make more sense in your real code. There seems to be a tendancy to use hash refs where a simple hash would do. This is equivalent to the above, far simpler, and more reliable because perl won't let you accidently overwrite the shared hash with a non-shared one as you've been doing with the unshared reference to a shared hash.

#!/usr/bin/perl

use warnings;
use strict;
use threads;
use threads::shared;
use Data::Dumper;

my %hash :shared;

sub sub1 {
  sleep 1;
  print threads->tid();
  print Dumper \%hash;
}

$hash{a} = &share({});

my $th1 = threads->new('sub1');
$hash{b} = &share({});
my $th2 = threads->new('sub1');

$th1->join();
$th2->join();
__OUTPUTS__
C:\test>junk1
1$VAR1 = {
          'a' => {},
          'b' => {}
        };

2$VAR1 = {
          'a' => {},
          'b' => {}
        };
[download]

(*)It would be interesting to see what the p5p guys make of that, cos it confuses the begebbers outta me!

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

Because I stripped down the part of my code to write a test case and kept the stupid bits that I came up with some time ago to avoid "Invalid value for shared scalar" messages without understanding why they were appearing?

Thanks a bunch I now understand my error.

For the record, I was assigning a thread object to an element of this shared hash, and using the above "strange overwriting technique" this somehow avoided the error message. Now I'm creating a "my" object reference, share it and assign it only then to the element of the shared hash.

Now this seems very complicated and I reckon I must have got lost somehow on the road. It's a bad idea to write production code whilst using modules for the first time, discovering design issues, circling back, discovering other issues... I think I'll start over ;-)

Now may I use your wisdom to get a hint on how you would design the code? Here's the big picture:

I'm simply trying to run multiple independent threads, each of which should periodically store some time-series numbers. Then a special thread would periodically take these numbers and do something with them (send them somewhere).

What I'm doing now is start the N threads plus the sending thread. Each thread handles its own infinite loop, and with its own interval. It stores its computed numbers in this shared hash. Now when the sending thread wakes up, it locks this hash, copies it to another, empties it and unlocks it. Then it can do whatever it likes with the copy

Regarding the corrected version of the code, I get different results randomly:

$ ~/perl/recycleshare3
2$VAR1 = {
          'a' => {}
        };
1$VAR1 = {
          'a' => {},
          'b' => {},
          'a' => {},
          'b' => {}
        };
$ ~/perl/recycleshare3
1$VAR1 = {
          'a' => {},
          'b' => {}
        };
2$VAR1 = {
          'a' => {},
          'b' => {}
        };
[download]