for($a=0;$a<=$filecounter;$a++){ 
$thr[$a]->exit(); 
}

for($a=0;$a<=$filecounter;$a++){ 
$thr[$a]=undef; 
}

for($a=0;$a<=$filecounter;$a++){ 
die $thr[$a]; 
}

for($a=0;$a<=$counter;$a++){ 
if($choice==1){ 
$thr[$a] = threads->create({'exit'=> 'thread_only'},sub {&ext1::submit($file)}); 
} 
else 
{ 
$thr[$a] = threads->create({'exit'=> 'thread_only'},sub {&ext1::reset($file)}); 
} 
$result[$a]=$thr[$a]->is_running(); 
}

#!/usr/bin/perl 
use strict; 
use warnings; 
 
# example of the ext1.pm  
{ 
   package ext1; 
   use Exporter; 
   our @EXPORTS_OK=qw(submit reset); 
 
   sub submit { 
	my ($id, $file) = @_; 
	print "Thread $id: submit $file\n"; 
	keys ( my %h ) = 1000; 
	sleep(2); 
   } 
 
   sub reset { 
	my ($id, $file) = @_; 
	print "Thread $id: reset $file\n"; 
	keys ( my %h ) = 1000; 
	sleep(15); 
   } 
   1; 
} 
 
# would normally choose use ext1 if was separate file ext1.pm     
# but since I have the package in the same file, I don't want to run require. 
import ext1;   
#use ext1; 
 
use threads; 
use Data::Dumper; 
$|++; 
 
my @files = (['file1',1],['file2',1],['file3',0],['file4',1],['file5',1]); 
my $options = {'exit'=>'thread_only'}; 
my $bar = "=" x 40; 
 
# open the threads 
 
my $start_mem = free_mem(); 
print "$bar\nSubmit processes\n$bar\n"; 
my @results; 
foreach my $i (0 .. $#files) { 
   my ($file,$choice) = @{$files[$i]}; 
   if ( $choice == 1 ) { 
      $results[$i] = threads->create( $options, sub { &ext1::submit($i,$file) } ); 
   } else {	 
      $results[$i] = threads->create( $options, sub { &ext1::reset($i,$file) } ); 
   } 
} 
 
# once threads are submitted, then need to either be joined or detached. 
 
# wait for each thread to be ready to be joined. 
 
sleep(2); 
my $thread_mem = free_mem(); 
print "$bar\nJoining threads\n$bar\n"; 
foreach my $i (0..$#results) { 
   print "thread $i: "; 
   while ( !$results[$i]->is_joinable() ) { print "."; sleep(1) } 
   print "ready\n"; 
   #$results[$i]->join;  # can join here as well 
} 
# join all the threads 
foreach my $r (@results) { 
   $r->join; 
} 
 
# check that all threads freed up 
 
print "$bar\nThread results\n$bar\n"; 
foreach my $i (0 .. $#results) { 
   print "thread $i: "; 
   while ( $results[$i]->is_running() ) { print "."; sleep(1) } 
   print "finished\n"; 
   #print Dumper($results[$i]); 
} 
 
sleep(10); 
 
print "$bar\nMemory\n$bar\n"; 
my $finish_mem = free_mem(); 
 
printf "Amt Free Mem at Start  : %d\n", $start_mem; 
printf "Amt Free Mem w/Threads : %d (%d)\n", $thread_mem, $thread_mem - $start_mem; 
printf "Amt Free Mem at End    : %d (%d)\n", $finish_mem, $finish_mem - $start_mem; 
print "done\n"; 
exit 0; 
 
sub free_mem { 
   return (split /\s+/, qx(free | grep ^Mem:) )[3];  
}

======================================== 
Submit processes 
======================================== 
Thread 0: submit file1 
Thread 1: submit file2 
Thread 2: reset file3 
Thread 3: submit file4 
Thread 4: submit file5 
======================================== 
Joining threads 
======================================== 
thread 0: ready 
thread 1: ready 
thread 2: .............ready 
thread 3: ready 
thread 4: ready 
======================================== 
Thread results 
======================================== 
thread 0: finished 
thread 1: finished 
thread 2: finished 
thread 3: finished 
thread 4: finished 
======================================== 
Memory 
======================================== 
Amt Free Mem at Start  : 2304404 
Amt Free Mem w/Threads : 2299016 (-5388) 
Amt Free Mem at End    : 2387748 (83344) 
done

for($a=0;$a<=$counter;$a++){  
if($choice==1){  
$thr[$a] = threads->create({'exit'=> 'thread_only'},sub {&ext1::submit($file)});  
}  
else  
{  
$thr[$a] = threads->create({'exit'=> 'thread_only'},sub {&ext1::reset($file)});  
}  
$result[$a]=$thr[$a]->is_running();  
} 
$sum_a=sum(@result); 
while($sum_a!=0) 
{ 
for($a=0;$a<=$counter;$a++){ 
$result[$a]=$thr[$a]->is_running();} 
$sum_a=sum(@result); 
} 
print("Operation finished\n");

 
for($a=0;$a<=$counter;$a++){   
if($choice==1){   
$thr[$a] = threads->create({'exit'=> 'thread_only'},sub {&ext1::submit($file)});   
}   
else   
{   
$thr[$a] = threads->create({'exit'=> 'thread_only'},sub {&ext1::reset($file)});   
}   
$result[$a]=$thr[$a]->is_running();   
} 
 
############################## 
for($a=0;$a<=$counter;$a++){ 
$result_join=$thr[$a]->is_joinable(); 
while($result_join!=1){ 
if ($thr[$a]->is_joinable()) { 
$thr[$a]->threads->detach(); 
$result_join=1; 
}}} 
############################## 
$sum_a=sum(@result);  
while($sum_a!=0)  
{  
for($a=0;$a<=$counter;$a++){  
$result[$a]=$thr[$a]->is_running();}  
$sum_a=sum(@result);  
}  
print("Operation finished\n");

threads->yield();  
my @list = threads->list(); 
printf ("Thread %d running %d\n", $_->tid, $_->is_running)  for @list; 
print "$bar\nContinuing\n$bar\n"; 
while ( @list = threads->list() ) { 
    foreach my $t (@list) { 
        if ( ! $t->is_running() ) { 
            printf "Thread %d is no longer running\n", $t->tid; 
            $t->detach; 
            if ( $t->is_detached ) { print "\tdetached\n" } 
            else { warn "Error: could not detach\n" } 
            my (@remaining) = threads->list(threads::running); 
            print "\t",scalar(@remaining)," threads remain\n"; 
        } 
    } 
    # do whatever else 
    sleep(1); 
} 
 
Output: 
 
======================================== 
Submit processes 
======================================== 
Thread 1 running 1 
Thread 2 running 1 
Thread 3 running 1 
Thread 4 running 1 
Thread 5 running 1 
======================================== 
Continuing 
======================================== 
Thread 5 is no longer running 
	detached 
	4 threads remain 
Thread 3 is no longer running 
	detached 
	3 threads remain 
Thread 4 is no longer running 
	detached 
	2 threads remain 
Thread 1 is no longer running 
	detached 
	1 threads remain 
Thread 2 is no longer running 
	detached 
	0 threads remain 
========================================

threads->yield(); # tells OS to let threads have cpu time 
while ( my @list = threads->list ) {     
    foreach my $t (threads->list(threads::joinable) ) { 
           my @result = $t->join; 
           # do whatever to the results from the thread 
            my (@remaining) = threads->list(threads::running); 
            print "\t",scalar(@remaining)," threads remain\n"; 
    } 
    # do other stuff 
   sleep(1); 
}

 
    $t->detach; 
    if ( my $err = $t->error() ) { print "Error: $err\n" }