threads::shared

If you're looking for a way to share variables across different threads or processes, look no further than threads::shared. This powerful Perl module allows you to share scalars and scalar refs, arrays and array refs, and hashes and hash refs between threads and pseudo-forks on Win32.

To get started with threads::shared, simply include it in your project like you would any other module. Then, declare the variables you want to share by adding the :shared tag to their declaration, like so:

my $var :shared;
my %hsh :shared;
my @ary :shared;

After declaring your variables, use the share() function to make them shareable:

share($scalar);
share(@array);
share(%hash);

Once your variables are set up for sharing, you can access and modify them using standard Perl syntax. For example:

$var = $scalar_value;
$var = $shared_ref_value;
$var = shared_clone($non_shared_ref_value);
$var = shared_clone({'foo' => [qw/foo bar baz/]});

Note that you can also share complex data structures by using shared_clone().

In addition to standard variable access, threads::shared provides several synchronization mechanisms to ensure safe access to shared variables. For example, you can use the lock() function to lock a hash for exclusive access:

{ lock(%hash); ... }

Or you can use the cond_wait(), cond_timedwait(), cond_broadcast(), and cond_signal() functions to coordinate access between threads.

Finally, if you need to synchronize access to a specific variable, you can use a separate lock variable with cond_wait() and cond_timedwait():

my $lockvar :shared;
# condition var != lock var
cond_wait($var, $lockvar);
cond_timedwait($var, time()+30, $lockvar);

Overall, threads::shared is an incredibly useful module for any Perl developer who needs to share variables between threads or processes. Its simple syntax and powerful synchronization features make it a must-have tool for concurrency programming.