while ($more_childs_to_produce) {
  $pid= open($child[$childnumber++], "-|");
  if ($pid) {   # parent
    # here we have another "file"
    # to read frome with <$child[$childnumber-1]>
  } else {      # child
    # Do the child's work and
    exit; 
  }
}
[download]

for ($i=0; $i<`#of children to do`; $i++;) {
  $pid[$i]= open($created_file_handle, "$custom_call_statement -|");
  if ($pid[$i]) { waitpid($pid[$i], 0); }  # parent waits for child to
+ finish
      } else { 
        while (<$created_file_handle>) { $out[$i] .= $_; } # add outpu
+t to the array
    exit; 
  }
}
[download]

Problem is, and it's the same when forking, that the parent can't see @out. Should I move the $out[$i] .= $_; to the parent process? The forked processes work fine, and fairly quickly, but I need to get the child to tell the parent what it found.

I'd rather not have to use the temp file solution, as it will get very messy when having multiple users run multiple processes at the same time. That's going to make this whole process run a lot slower. I'd rather see if I can find a solution that passes data faster back to the main process.

To be honest... I really don't understand your code above. Sorry...
But then... Here is a complete program that might help you. It forks 2 children and collects the children's output in an array.
Be aware that there is no error handling (can't fork etc.) yet.

use warnings;
use strict;

my $children= 2; # How many to fork
my @out;
my $first_child;

$|=1; # unbuffered output to see the effect

my $pid= open($first_child, '-|');
if ($pid) {
    # parent: Collects all output
    @out= <$first_child>;
}
else {
    # child forks again and produces output
    my(@child, @childpid);
    for (my $i=0; $i<$children; ++$i) {
        $childpid[$i]= open($child[$i], '|-');
        if ($childpid[$i]) {
            # parent
            # does nothing yet
        }
        else {
            # child produces some output
            my $j=10;
            while ($j--) {
                print "I'm child $i and will tell this $j more time(s)
+\n";
                sleep 1;
            }
            exit;
        }
    }
    foreach (@child) {
        # closing all child handles
        close $_;
    }
    exit;
}

print @out;
[download]

If the passage of data is 'one-way', that is to say the master program is only going to collect results from the child program/process after it's completed, a temp file is much simpler.

If all of the processes are running on the same machine, then you can use the process id($$) of a process as part of the filename, since the process id is guaranteed to be unique.

Yes, IO::Select is right for this.

IO::Select will work fine for filehandles other than sockets. You just need to give the fileno of the handle as argument to the IO::Select instance's add() method, or else wrap the pipe's output handle in IO::Handle and use that object as the argument.