I've done almost no work involving threaded apps, and only one or two projects using sockets, but it occurs to me that you would be better off having your main program request the report from the client via the thread (i.e. always use your thread to handle the socket comms.).

This is the basic client I use, which splits itself for birdirectional communication. So all you need to do is in your server, send reports with a header like <report> $report </report>, and have your client regex for it and handle it.

#!/usr/bin/perl -w
use strict;
use IO::Socket;

my ( $host, $port, $kidpid, $handle, $line );
#unless ( @ARGV == 2 ) { die "usage: $0 host port" }
( $host, $port ) = @ARGV || ('localhost',8989);

# create a tcp connection to the specified host and port
$handle = IO::Socket::INET->new(
    Proto    => "tcp",
    PeerAddr => $host,
    PeerPort => $port
  )
  or die "can't connect to port $port on $host: $!";
$handle->autoflush(1);    # so output gets there right away
print STDERR "[Connected to $host:$port]\n";

# split the program into two processes, identical twins
die "can't fork: $!" unless defined( $kidpid = fork() );

# the if{} block runs only in the parent process
if ($kidpid) {

    # copy the socket to standard output
    while ( defined( $line = <$handle> ) ) {
                      print STDOUT $line;
                      }
    kill( "TERM", $kidpid );    # send SIGTERM to child
}

# the else{} block runs only in the child process
else {

    # copy standard input to the socket
    while ( defined( $line = <STDIN> ) ) {
        print $handle $line;
    }
}
[download]

the reason for having threads is simple : one thread has to wait on a line arriving from the user (client), respond to it, and repeat for ever. The other has to just report back autonomously every second. The responses seen at the client should look like this:

OK
OK
?
report: 27
OK
?
report: 36
OK
[download]

With OK and ? being the responses to client commands. As you say, they are received by the same piece of code which parses them and acts appropriately. That's fine, and nothing to do with needing threads, which is a result of needing to both wait for user input AND act autonomously.

The simple solution, which I'll likely take, is juts to poll periodically from the client. I just liked the idea of being able to say "start reporting" ... "stop reporting" instead of that.

Whether it's a limitation of Win32 sockets or Perl or sockets in general, attempting to send to a socket whilst simultaneously in attempting to read from it doesn't work. It's not a limitation of threads, though without threads simultaneously reading and writing is a bit harder :)

To alleviate the problem, it's necessary to set the socket into non-blocking mode and use sysread rather than the buffered IO primitives.

This code does pretty much what you've ask for, but don't take it as being a good example of anything :) Just a starting point:

#! perl -slw
use strict;
package threads::SimpleServer;
use threads;
use Thread::Queue;
use IO::Socket qw(:DEFAULT :crlf);
use Time::HiRes qw( usleep );

our @ISA = 'Thread::Queue';

our $die:shared = 0;

sub listener {
    my( $in, $out, $port ) = @_;
    my $sock = new IO::Socket::INET (
        LocalAddr => "localhost", LocalPort => $port,
        Proto => 'tcp', Listen => 1, Reuse => 1
    );

    my $client = $sock->accept;
    async {
        ioctl( $client, 0x8004667e, pack( 'V', 1 ) ) or die $^E;

        my( $buffer, $p ) = ( '', 0 );
        while( not $die ) {
            local $\ = CRLF;
            print $client $out->dequeue while $out->pending;
            my $bytes = sysread( $client, $buffer, 1024, length( $buff
+er ) );
            last unless defined $bytes or 0+$^E == 10035;
            sleep 1 and next unless $p = 1+index( $buffer, CRLF );
            $in->enqueue( substr( $buffer, 0, $p+1, '' ) ) 
                 while $p = 1+index( $buffer, CRLF );
        }
    }->detach;
}

sub new {
    my( $class, %args ) = @_;
    my( $in, $out ) = map{ bless Thread::Queue->new(), $class } 1 .. 2
+;
    threads->create( \&listener, $in, $out, $args{ port } || 1000 )->d
+etach;
    return $in, $out;
}


1;
package main;
use threads;
#use threads::SimpleServer;

my( $in, $out ) = threads::SimpleServer->new( port => 1000 );

async{
    my $reportNo;
    $out->enqueue( 'report:' . ++$reportNo ) while sleep 1;
}->detach;

while( my $cmd = $in->dequeue ) {
    warn "got:'$cmd'";
    $out->enqueue( ( rand > 0.5 ) ? 'OK' : '?' );
}

END{ our $die = 1; sleep 1 }
[download]