Re^2: Perl thread confustion

[7stud]

All lexical (my) variables are local to the thread they are declared in. Unless they are: Implicitly cloned by being made closures.

Okay, here is a closure:

{
    my $x = 20;

    sub do_stuff {     
        print "$x \n"; 
    }

}

do_stuff();  #$x has gone out of scope here

--output:--
20           #…yet the sub can still see $x

But in the following thread can the sub see $x because it closes over $x, or can the sub see $x because:

All lexical (my) variables are local to the thread they are declared in. Unless they are: Implicitly cloned because they exist in the spawning thread prior to a 'child' thread being spawned.

use threads;
use threads::shared;


my $x = 20;

sub do_stuff{ 
    print "$x \n";    #closes over $x (as above)
}

threads->create(\&do_stuff)->join();

--output:--
20

If perl copies all the data to a thread, why doesn't the following code also output 20:

use threads;
use threads::shared;

sub do_stuff{ 
    print "$x \n";   #doesn't close over $x
}

my $x = 20;         

threads->create(\&do_stuff)->join();   #perl copies $x to the thread
                                        

--output:--
<blank line>    #but the thread can't see $x

[BrowserUk]

But in the following thread can the sub see $x because it closes over $x, or can the sub see $x because:

It can see it, because the sub closes over it.

But it would have been copied to the new thread anyway even if the sub didn't close over it -- because it existed when the thread was spawned -- but it isn't useful within the thread because if it isn't closed over, nothing can see it (nor therefore use it).

Hence my comment "I have no idea why this happens. In my opinion it should not.".

If perl copies all the data to a thread, why doesn't the following code also output 20:

Enable strict or warnings and perl will tell you why.

(And note: I didn't say "all the data"; I said "exist in the spawning thread prior to a 'child' thread being spawned." It is a subtle, but very important difference.)

But, if you doubt my assertion that non-closed-over variables created after the thread sub is declared but before it is spawned are also cloned, run this and monitor the memory usage using the task manager or your OS equivalent:

perl -Mthreads -wE"sub x{ sleep 100 }; my @x=1..1e7; sleep 10; async(\
+&x)->detach; sleep 100"

What you'll see is something like this. The array is created and memory usage jumps to ~900MB and levels out for 10 seconds before the thread is spawned. It then jumps to ~1.9GB. Despite that the thread can never make any use of the copy that is made, because it is not lexical visible to it.

It makes no sense whatsoever, but try getting anyone to change it.

But, as I said above, the good news is that it is easy to avoid, by spawning your threads before you populate data structures used by your main thread code.

[7stud]

- but it isn't useful within the thread because if it isn't closed over, nothing can see it (nor therefore use it). Hence my comment "I have no idea why this happens. In my opinion it should not.".

I see. So data is copied, but it is not accessible. Seems like a great feature!