use threads;

use Thread::Queue qw( );
         
my $num_drives = 3;
my $num_discs = 12;

my $q = Thread::Queue->new();
$q->enqueue( 1..$num_discs );
$q->enqueue( (undef) x $num_drives );

for my $drive (1..$num_drives) {
    ... eject disc ...
    async {
        while (defined(my $disc = $q->dequeue())) {
            print("Please insert disc $disc in drive $drive\n");
            ... wait for disc to be present ...
            ... read disc ...
            ... eject disc ...
        }
    };
}

$_->join for threads->list();
[download]

Thanks much ikegami for the quick reply and code example. I'll do some reading now and play with your code to learn a little. Thanks again for the example!

I personally like Parallel::Forker - it makes polling processes easy, and also gives you a lot of control over them, so you can monitor them pretty closely. Have a look and see what you think.

Thanks much for the reference! Off to do some reading...

I thought later that Parallel::ForkManager is another good option for you, if you want to keep things simple. There is a tutorial here in the Monastery : Introduction to Parallel::ForkManager

Just a something something...

Otherwise, you could implement a simple queue - each child fetches the next number from the queue, reads that disk, and repeats until the queue is empty. You could use a file or a database table for the queue (remember to lock!). Or you could have the children read from a pipe.

Another idea is to have each child read one CD. If the CD has been read, the child terminates. Parent notices the child terminates (wait/waitpid) and forks a new one. New child should be passed both a drive and a CD number.

use POSIX qw( _exit );

my $num_drives = 3;
my $num_discs = 12;

my @idle;  # Idle drives
my %busy;  # Busy drives, keyed by the pid using them

sub wait_for_a_kid {
    my $pid = wait();
    if ($pid == -1) {
        warn("Can't wait: $!\n");
        return 0;
    }
    ... check the child's exit code if desired ...
    push @idle, delete($busy{$pid});
    return 1;
}

for my $drive (1..$num_drives) {
    ... eject disc ...
    push @idle, $drive;
}

my @queue = 1..$num_discs;
while (@queue) {
    if (!@idle) {
        last if !wait_for_a_kid();
    }

    my $disc = shift(@queue);
    my $drive = shift(@idle);
    my $pid = fork();

    if (!defined($pid)) {
        warn("Can't fork: $!\n");
        last;
    }

    if ($pid) {
        $busy{$pid} = $drive;
        next;
    }

    if (!eval {
        print("Please insert disc $disc in drive $drive\n");
        ... wait for disc to be present ...
        ... read disc ...
        ... eject disc ...
        1;
    }) {
        warn($@);
        _exit(1);
    }
    _exit(0);
}

while (keys(%busy)) {
    last if !wait_for_a_kid();
}
[download]

Update: Added some error checking. Fixed a bug exit wait loop.

You are violently agreeing with the OP. He said the fourth child should be forked after one of the original three had exited, meaning at most three children exist at any given time.