Question

I think this might be a fairly easy question.

I found a lot of examples using threads and shared variables but in no example a shared variable was created inside a thread. I want to make sure I don’t do something that seems to work and will break some time in the future.

The reason I need this is I have a shared hash that maps keys to array refs. Those refs are created/filled by one thread and read/modified by another (proper synchronization is assumed). In order to store those array refs I have to make them shared too. Otherwise I get the error Invalid value for shared scalar.

Following is an example:

my %hash :shared;

my $t1 = threads->create(
    sub { my @ar :shared = (1,2,3); $hash{foo} = \@ar });
$t1->join;

my $t2 = threads->create(
    sub { print Dumper(\%hash) });
$t2->join;

This works as expected: The second thread sees the changes the first made. But does this really hold under all circumstances?

---

Some clarifications (regarding Ian’s answer):

I have one thread A reading from a pipe and waiting for input. If there is any, thread A will write this input in a shared hash (it maps scalars to hashes… those are the hashes that need to be declared shared as well) and continues to listen on the pipe. Another thread B gets notified (via cond_wait/cond_signal) when there is something to do, works on the stuff in the shared hash and deletes the appropriate entries upon completion. Meanwhile A can add new stuff to the hash.

So regarding Ian’s question

[…] Hence most people create all their shared variables before starting any sub-threads.

Therefore even if shared variables can be created in a thread, how useful would it be?

The shared hash is a dynamically growing and shrinking data structure that represents scheduled work that hasn’t yet been worked on. Therefore it makes no sense to create the complete data structure at the start of the program.

Also the program has to be in (at least) two threads because reading from the pipe blocks of course. Furthermore I don’t see any way to make this happen without sharing variables.

Answer 1

I don’t feel good answering my own question but I think the answers so far don’t really answer it. If something better comes along, I’d be happy to accept that. Eric’s answer helped though.

I now think there is no problem with sharing variables inside threads. The reasoning is: Threads::Queue‘s enqueue() method shares anthing it enqueues. It does so with shared_clone. Since enqueuing should be good from any thread, sharing should too.