Async::Group - Perl class to deal with simultaneous asynchronous calls
use Async::Group ; use strict ; sub sub1 { print "Dummy subroutine \n"; my $dummy = shift ; my $cb = shift ; &$cb(1); } sub allDone { print "All done, result is ", shift ,"\n" ; } my $a = Async::Group->new(name => 'aTest', test => 1) ; $a->run(set => [ sub {&sub1( callback => sub {$a->callDone(@_)} )}, sub {&sub1( callback => sub {$a->callDone(@_)} )} ], callback => \&allDone ) # or another way which avoids the clumsy nested subs my $cb = $a->getCbRef(); $a->run(set => [ sub {&sub1( callback => $cb)}, sub {&nsub1( callback => $cb )} ], callback => \&allDone )
If you sometimes have to launch several asynchronous calls in parrallel and want to call one call-back function when all these calls are finished, this module may be for you.
Async::Group is a class which enables you to call several asynchronous routines. Each routine may have their own callback. When all the routine are over (i.e. all their callback were called), Async::Group will call the global callback given by the user.
Note that one Async::Group objects must be created for each group of parrallel calls. This object may be destroyed (or will vanish itself) once the global callback is called.
Note also that Async::Group does not perform any fork or other system calls. It just run the passed subroutines and keep count of the call-back functions called by the aforementionned subroutines. When all these subs are finished, it calls another call-back (passed by the user) to perform whatever function required by the user.
Using fork or threads or whatever is left to the user.
Creates a new Async::Group object.
parameters are : - name: name of the group. The name has no special meaning but it can be helpfull for debugging. - test: will print on STDERR what's going on
- set: array ref of a set of subroutine reference that will be called in parrallel - callback : global user callback function
Function to be called back each time an asynchronous call is finished.
When all function calls are over (i.e. all call-back were performed) all the returned results are logically 'anded', the passed strings are concatenated and the resulting result is passed to the global user call-back function passed with the run() method.
Syntactic sugar to avoid nested subs when defining the set of routines that must be run in parrallel. This function will return a sub ref that can be used as a callback function by the user's routine.
So you may call run() with the following sequence :
my $cb = $a->getCbRef(); $a->run(set => [ sub {&sub1( callback => $cb)}, sub {&nsub1( callback => $cb )} ], callback => \&allDone )
Dominique Dumont, Dominique_Dumont@grenoble.hp.com
Copyright (c) 1998 Dominique Dumont. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
perl(1)
To install Async::Group, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Async::Group
CPAN shell
perl -MCPAN -e shell install Async::Group
For more information on module installation, please visit the detailed CPAN module installation guide.