The way to do this ... is to do what the shells do:   spawn multiple processes and wait for all of them to complete.   I suggest that you start your search with Parallel::ForkManager.

There are many more-sophisticated workflow management tools available, e.g. POE, so as you are contemplating your requirements try to articulate them carefully.   It is very unlikely that you will have to “write anything new,” even when building a very complex application of this general type, so if you find yourself thinking that you do, step back and keep looking in http://search.cpan.org (and of course, right here).

You could use "naked" fork for this, but it looks like Parallel::ForkManager would let you write the code pretty much the way you wrote it in your example.

There are various modules on CPAN for this.  One of them is Proc::Background:

use Proc::Background;

my @params = ...

my @procs;
for my $p (@params) {
    my $cmd = "some-command $p > /tmp/some-file.$p";
    push @procs, Proc::Background->new($cmd);
}

$_->wait for @procs;

# ... continue work
[download]

One further thought:   if you have a lot of these commands to issue, set up a thread-safe FIFO queue (or pipe, as the case may be) that you push the commands into, and set up a limited number of worker threads/processes that pop work-requests off of that queue.   The queue provides the necessary “flexible hose” that keeps the system from over-committing itself if a sudden flood of requests appears.

Simple shell-scripts sometimes do not take this into consideration, and the not-so affectionate name for what happens (sometimes used as a denial-of-service attack) is a “fork bomb.”

Parallel::ForkManager (which you originally suggested) provides a simple way to specify the maximum number of parallel processes — no need to reinvent the wheel.