This isn't what you want, but it is what you have asked for. And it is rather less cumbersome than Thread::Pool:

#! perl -slw
use strict;
package pool;
use threads;
use Thread::Queue;

sub new{
    my $class = shift;
    my $nThreads = shift;
    my $Qin = new Thread::Queue;
    my $Qout = new Thread::Queue;
    my @threads = map{
        threads->new(
            sub {
                my( $Qin, $Qout ) =  @_;
                while( my $code = $Qin->dequeue() ) {
                    $Qout->enqueue( eval $code );
                }
            }, $Qin, $Qout
        )
    } 1 .. $nThreads;
    return bless [ $Qin, $Qout, \@threads ], $class
}

sub job {
    my( $Qin, $Qout, $threads ) = @{ +shift };
    $Qin->enqueue( shift );
    return;
}

sub DESTROY {
    my( $Qin, $Qout, $threads ) = @{ +shift };
    $Qin->enqueue( undef ) for @$threads;
    sleep 0;
    $_->join for @$threads;
}

*stop = *stop = *DESTROY;

package main;

my $pool = pool->new( 5);

for ( 1 .. 1000 ) {
    $pool->job( qq[ 
        sleep 5; 
        printf "In thread(%d). arg:%d\n", threads->tid, $_
    ] );
}
sleep 10;
$pool->stop;

__END__
c:\test>543977
In thread(1). arg:1
In thread(2). arg:2
In thread(3). arg:3
In thread(4). arg:4
In thread(5). arg:5
In thread(1). arg:6
In thread(2). arg:7
In thread(3). arg:8
In thread(4). arg:9
In thread(5). arg:10
In thread(1). arg:11
In thread(2). arg:12
In thread(3). arg:13
In thread(4). arg:14
In thread(5). arg:15
In thread(4). arg:16
In thread(3). arg:17
[download]

Here is an example using Tk Tk-with-worker-threads

It demonstrates a "sleeping thread pool". The script allows you to set how many to make ( set up as max= 3), then it keeps an array, which you shift and push, to keep track of available (free) workers. You can pass code to it, and get results thru shared variables. I just have it open and xterm, and when you close the xterm, a count starts. When the thread is finished or cancelled, it goes back to sleep, and is pushed back into the available-array. I have the sleep time as 1 second, but you can improve responsiveness by using a miliisecond value ( select(undef,undef,undef,.01). It will still use very little cpu when sleeping at that interval.

The sleeping thread loop is the essence of what you are after, in the sub "work". I used a goto in it, as a simple way of killing the thread , but you could use a "return" instead.

P.S. The reason I use Tk, is that it allows for an event-loop to monitor the thread's shared vars from main. This is your big problem. The main script will NOT see changes in shared vars, until it actively reads it. So you need a loop of somekind. Maybe POE, Event, or another option like Roll your own Event-loop

I got Thread::Pool working.

Could you post your working version please.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

I think the OP means that his original version works, just not under the debugger.

#!/usr/bin/perl

use strict;
use warnings;

use Thread::Pool;

my $pool = Thread::Pool->new({workers => 10,
                              do      => \&do,
                              monitor => \&monitor});

my @jobs = ('A' .. 'Z');

my $count;
for (@jobs) {
    print $count++, "\n";
    $pool->job($_);
}

sub do {
    my $letter = shift;
    print "begin: $letter\n";
    for (1 .. 10000000) {
        my $x = $_ ^ 2;
    }
    print "end: $letter\n";
    return "$letter is back\n\n";
}

sub monitor {print shift}
[download]