Depending on the details of what you want from the kids, there are several ways.

1. Parallel::ForkManager lets you set a maximum number of processes which all have the same code. When one exits, another will appear.
2. A $SIG{CHLD} handler can arrange to replace a finished process with another.
3. A wait loop can fork a replacement.

What do your processes do? It's not clear from your description that either process needs to exit until the work is done.

Hello,


First off, thank you for your reply. I believe signals will work gret.

<snip> It's not clear from your description that either process needs to exit until the work is done. </snip> I am not trying to be an asshole, but I didn't think I needed to be clear as to why I needed two processes running at the same time. I thought I could just say it. But since it may help, here is my response.

The process is nget. Nget is a command-line usenet binary grabber. The reason that I want two ngets to run at the same time is so that I have two connections to my usenet provider. Without at least two ngets running I don't get as good of download time (Retrieving articles then assembling takes some time away from downloading).

Sounds like a case for Parallel::ForkManager.

After Compline,
Zaxo

You could do it the easy way.

#! perl -slw
use strict;
use threads qw[ async yield ];
use Thread::Queue;

my $Qrv = new Thread::Queue;

my @work = qw[ C: D: P: Q: T: U: V: W: Z: ];

for ( 1 .. 2 ) {
    my $cmd = join ' ', 'dir /s', shift( @work ),  '>nul';
    async( sub{ $Qrv->enqueue( "$_: " . system( $cmd ) ); } )->detach;
}

while( @work ) {
    my( $threadNo, $rv ) = split ': ', $Qrv->dequeue();
    my $cmd = join ' ', 'dir /s', shift( @work ),  '>nul';
    async( sub{ $Qrv->enqueue( "$threadNo: " . system( $cmd ) ); } )->
+detach;
}

sleep 2;
[download]

A slightly more verbose version shows the workings

Instead of that I usually try to have a pipe into the processes and poll/select on them. Most programs don't close the standard handles, so you can actually use these. In this case I use STDIN.

The following code demonstrates the idea. Modify it to fit whatever your constraints are.

#! /usr/bin/perl -w
use 5.008;
use strict;
use IO::Select;

# program and args
my @work = qw(sleep 3);
my $wanted = 2;

my $s = IO::Select->new;
my $have = 0;

while ($wanted) {
    while ($have < $wanted) {
        open(my $fh, "|-", @work) || die "Could not fork: $!";
        $s->add($fh);
        $have++;
    }
    for ($s->can_read()) {
        $s->remove($_);
        $have--;
        close $_;
        die "Unexpected returncode $?" if $?;
        # Real code may change $wanted here
    }
}
[download]