Just as a general design idea, how about a combination of putting some code at the end of the thread code block, to indicate it is done, with a timeout on each thread.

To catch all the malfuctioning threads, launch each thread with a sister timer thread. When a preset timeout is hit, the main thread kills() the hung thread; or when the thread finishes properly, it is all cleaned up.

You may be better off using an event-loop system for launching the threads, and avoid the sister thread, by using eventloop timers.

#!/usr/bin/perl -w
use strict;
use threads;
use threads::shared;

my $timer_go:shared = 0;

my $worker = threads->create(\&worker);
my $timer = threads->create(\&timer,$worker)->detach();

print "hit enter to start\n";
<>;
$timer_go=1;


while( (scalar threads->list) > 0   ){
 print scalar threads->list,"\n"; 
 sleep 1;
foreach my $thread (threads->list) {
   if( $thread->is_joinable ){ $thread->join;}
   }
}

print "worker joined, all done\n";
exit;


sub timer {
  my $worker = shift;
   while(1){     
       if($timer_go){
        my $count = 0;
             while(1){ 
                  $count++;
                  if($count > 5){    
                         print "timed out\n";
                          # Send a signal to a thread
                         $worker->kill('INT');
                         return; # will destroy a detached thread
                        } 
                  sleep 1;
                  print "timing $count\n";
            }
       }else{sleep 1}
    }
}

sub worker {
       $|++;
       $SIG{INT} = sub{ warn "Caught Zap!\n"; threads->exit() };
       # threads->exit() will exit thread only
       

      while(1){sleep 1;  next}

      return;
}
[download]