If you have access to 5.8 you could always try threads. They certainly simplify the use of shared data with asynchronous processing.

Some simplistic test code. I'm still getting to grips with Perls flavour of threading myself, so please take this with a very large pinch of salt.

I'd really appreciate anyones critique of this code.

#! perl -slw
use strict;
use threads;
use threads::shared;

package My::Singleton;

my $count : shared = 0;
sub new{
    return __PACKAGE__;
}

sub incMe{ lock( $count ); ++$count }
sub decMe{ lock( $count ); --$count }
sub Me : lvalue { lock( $count ); $count }

1;
package main;


sub worker{
    my ($ctl) = @_;
    my $me = threads->self;
    my $singleton = My::Singleton->new();

    while($$ctl) {
        print $me, ' gets ', $singleton->Me();
        sleep rand 3;
        print $me, ' increment to: ', $singleton->incMe();
        sleep rand 3;
        print $me, ' decrements to: ', $singleton->decMe();
        sleep rand 3;
        print $me, ' sets: ', $singleton->Me() = int rand 1000 if rand
+() < 0.1;
        sleep rand 3;
    }
    print $me, ': Bye!';
    return "$me: ended with " . $singleton->Me();
}
my @flags : shared = (1) x 10;
my @threads = threads->new( \&worker, \$_ ) for @flags;

sleep 30;
print 'Telling kids its time to go';
#!!! BAD IDEA.>> @flags = (0) x 10; << DO NOT USE!! [hossman]++
$_-- for @flags; # Better, *I think*.

print 'Waiting...';
$_->self != threads->self and print($_->join) for threads->list;
[download]