Well I ran into some glitches, and the net result is it's probably easiest just to let each thread write to it's own separate file. Of course, your superior insights may see a way out.

I had to create a dummy file, in order to get some fileno's, and although select does seem to intercept the thread writes, they still go to file directly, so there dosn't seem to be any use for the select, except to intercept the data as it's being written to disk. Also the select seemed to repeat it's data reads, but that probably could be fixed.

Before I saw the above glitch, my idea was to have each thread search thru it's list for primes, and only print back to main when a prime was found in it's range.

Conclusion: My original suggestion of letting each thread print to it's own output file, and merging them after script completion, is probably best. Maybe if one used an event loop system, a filehandle watch could be used without the need for a disk file to get a fileno, but then you would be displaying results to a widget of some sort.

#!/usr/bin/perl
use warnings; 
use strict;
use threads;
use IO::Select;
use FileHandle;

my @ranges = ( [1,10000000],[10000001,20000000],[20000001,30000000],
               [30000001,40000000],[40000001,50000000] );

my $sel = new IO::Select();

# thread launching

foreach (@ranges){
  my $fh = FileHandle->new();

  open ($fh,'+>', './dummyfile'); 
# needed to get filehandle to give a fileno
# maybe better to use IO::Handle and give it
# a fileno directly?

    my $start = $_->[0];
    my $end = $_->[1];
    my $fileno = fileno($fh);
    print "$start $end $fileno\n";

  threads->create( \&thread, $start, $end, $fileno )->detach;
  
  $sel->add($fh);
}

# watching thread output
print "Watching\n\n";
#while( scalar (threads->list) > 0 ){  # dosn't seem to work

while(1){     
       
     foreach my $h ($sel->can_read){
         my $buf;
         if ( (sysread($h, $buf, 1024) > 0 ) ){ 
           print "Main says: $buf\n"; 
           #truncate $h, 0;  # bad idea :-)
         }
     }
}


sub thread{

my( $start, $finish, $fileno ) = @_;

open my $fh, ">&=$fileno" or warn $! and die;
print $fh  "thread# ",threads->tid()," -> $start, $finish, $fileno \n"
+  ;

sleep 5;

print $fh  "thread# ",threads->tid()," -> finishing \n"  ;

}
__END__
[download]

#!/usr/bin/perl
use warnings; 
use strict;
use threads;
use IO::Select;
use IO::Pipe;

my @ranges = ( [1,10000000],[10000001,20000000],[20000001,30000000],
               [30000001,40000000],[40000001,50000000] );

my $sel = new IO::Select();

# thread launching

foreach (@ranges){

    my $pipe = IO::Pipe->new();
    my $start = $_->[0];
    my $end = $_->[1];
    print "$start $end $pipe\n";

  threads->create( \&thread, $start, $end, $pipe )->detach;

  # only call reader after pipe has been passed to thread  
  $sel->add( $pipe->reader() );
}

# watching thread output
print "Watching\n\n";

while(1){     
     
     foreach my $h ($sel->can_read){
         my $buf;
         if ( (sysread($h, $buf, 1024) > 0 ) ){ 
           print "Main says: $buf\n"; 
         }
     }
}


sub thread{

my( $start, $finish, $pipe ) = @_;

my $wh = $pipe->writer;
$wh->autoflush(1);

print $wh  "thread# ",threads->tid()," -> $start, $finish, $pipe \n"  
+;

sleep 5;

print $wh  "thread# ",threads->tid()," -> finishing \n"  ;
sleep 2;

}

__END__
[download]

Sorry, but I still do not understand how this in any way helps solve the OPs problem?

---

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

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

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

The OP said he was successful in splitting his huge file and putting each chunk into a thread for processing, but was unsure on how to collect the output generated by each thread. He said a database write was unacceptable to his boss.

The concept of each thread writing to it's own output file and merging them after script completion didn't appear a good solution to him, or else he wouldn't have brought the issue up.

Consider a situation where the threads process millions of records, but only need to report back a few matches. This method will allow the main thread to collect those matches, and operate on them in realtime. Otherwise the main thread would have to tail the thread's output files.

---

I'm not really a human, but I play one on earth.
Old Perl Programmer Haiku ................... flash japh