Reusable threads demo

[zentara]

A few recent nodes could be solved by reusable threads. All my examples were for Tk or Gtk2, so this is a pure commandline demonstration. It starts 10 reusable threads as a pool, and cycles thru the alphabet. Each thread will pick up a letter, and count to 10 with it( with random time intervals). When done a thread is made available for reuse, and this continues until the data(alphabet) is exhausted and all threads finish. It's not perfect. I use some goto's to break out of nested loops, and some other acrobatics. :-) If anyone can see how to avoid the goto's, with the same clarity, please post it. :-)

This concept is useful when you have objects in your threads which are not totally threadsafe. Reusing threads will usually save some memory gains often associated with creating/destroying/creating threads.

I tried to keep it as simple as possible, so a new threads user can see what is happening.

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

my %shash;
my @to_be_processed = ('a'..'z');
my @ready:shared = ();

my $numworkers = 10;

foreach my $dthread(1..$numworkers){
  share $shash{$dthread}{'go'};
  $shash{$dthread}{'go'} = 0;
  
  share $shash{$dthread}{'fileno'}; #in case you want 
  $shash{$dthread}{'fileno'} = '';  #shared filehandles
  
  share $shash{$dthread}{'data'};
  $shash{$dthread}{'data'} = '';
  
  share $shash{$dthread}{'pid'};
  $shash{$dthread}{'pid'} = -1;
  
  share $shash{$dthread}{'die'};
  $shash{$dthread}{'die'} = 0;
  
  $shash{$dthread}{'thread'} = threads->new(\&worker, $dthread);
  push @ready, $dthread;   
}

print "\t\t",scalar @ready," threads ready.......press a key to start 
+threads\n";
<>;

while (my $t = shift(@ready)){
     $shash{$t}{'data'} = shift @to_be_processed;
     $shash{$t}{'go'} = 1; 
}


while(1){

    if( scalar @ready > 0 ){

         if( my $data = shift @to_be_processed ){
            my $t = shift(@ready);
            $shash{$t}{'data'} = $data;
            $shash{$t}{'go'} = 1; 
            print "thread $t restarting\n";
          }else{ print "out of input\n"; goto WAIT;  }
     }
}

WAIT:
print "\n\n\nWAITING FOR FINISH\n\n\n";

while(1){
  print "\n\n\n",scalar @ready," are ready\n\n\n";
 if ( scalar @ready < $numworkers  ){ sleep 1}else{
 
      foreach my $t(@ready){
        $shash{$t}{'die'} = 1;
        $shash{$t}{'thread'}->join;
        print "joining thread $t\n";
        }
      exit;  
    }

}




sub worker{
   my $thr_num = shift;
   print "$thr_num started\n"; 

   #create your reusable objects here if needed
   
my $count;
START:  
   while(1){
      
      if( $shash{$thr_num}{'die'} ){
             print "thread $thr_num finishing\n"; 
             return} 
      #wait for $go_control  
      if($shash{$thr_num}{'go'}){      
          
                 if($shash{$thr_num}{'die'}){
                    print "thread finishing\n"; 
                           return} 
               
               $count++;            
               my $str = '    'x$thr_num; #printout spacer
               print $str.$thr_num.'->'.$count.$shash{$thr_num}{'data'
+},"\n";
          
           if ($count > 10){ goto RECYCLE; }
    
           #select(undef,undef,undef,.25);
               sleep rand 5
        
        }else{ 
         $count = 0;
         select(undef,undef,undef,.25); }# sleep until awakened 
   } #end while(1)

RECYCLE:
$shash{$thr_num}{'go'} = 0;
print "$thr_num done....going back to sleep\n";
$shash{$thr_num}{'data'} = '';

#  clean out temp data from objects here, if needed
#  see "perldoc -q clear" 

$count = 0;
push @ready, $thr_num;
print "pushing $thr_num\n";
goto START;
return;
}