It depends on how many kids you have, what the system load is like, and how long the jobs take to process if this is a workable solution.

It seems conceptually easier to me than trying to coordinate lots of children trying to write to the same pipe in the parent, but that's just me.

• select for info about the older non OO version of select
• IO::Select for info about the OO version listed below
• perlman:IPC::Semaphore and IPC::SysV if you want to implement some kind of process locking (you hint that you do but should not have to with select)
• Here For a comprehensive treatment of the use of select. (Old non OO stylee)
• Look at Section 7.13 of the cook book for the original reference to the code mapped out below

use IO::Select;

open FHANDA,"processA|" || die("..");
open FHANDB,"processA|" || die("..");
open FHANDC,"processA|" || die("..");

$Select = IO::Select->new();
$Select->add(*FHANDA);
$Select->add(*FHANDB);
$Select->add(*FHANDC);
if (@ready = $slect->can_read(0))
{
  for (@ready)
  {
    #Process the file handle (do the read and write)
  }
}
[download]

Here's a sample script, with debugging lines left in for flavor:

#!/usr/bin/perl -w

use strict;
use Expect;
$Expect::Multiline_Matching = 0;
my @todo = ("ls /etc", "ps axw", "du");
my @cmds;
foreach my $cmd (@todo) {
    print "spawning $cmd\n";
    push @cmds, Expect->spawn($cmd);
    die "Didn't spawn $cmd\n" unless $cmds[-1];
}
print "cmds = @cmds\nExpecting...\n";
while (@cmds) {
    expect(
       1,
       '-i', \@cmds,
       [
        qr"^.*\n",
        sub {print "\n", shift, " did something\n"; exp_continue;}
       ],
       [
        'eof',
        sub {
        my $done = shift;
        print "$done is finished\n";
        @cmds = grep {$_ != $done} @cmds;
        print "cmds = @cmds\n";
        }
       ],
      );
}
print "Everything finished\n";
[download]

One benefit of going this route is that you could put in pattern matches for rsh error output and take special action, while ignoring most of the output.

Expect is nice for letting you take care of things that matter and ignore the bulk of a process's output.