Rather than messing around with IO::String or in-memory files and then needing to use substr to try and extract the new bits of the log etc., I think I have an alternative that will achieve your aim.

The basic idea is to tie a filehandle to a Thread::Queue object, which can be shared across threads. You tie a filehandle and then pass this into each of your Telnet threads and they pass it to their respective Net::Telnet objects for logging.

Your main thread can retrieve the thread::Queue handle from the tie and the loop over reading from it and displaying what it gets into the appropriate window(s). It can also, output the lines to the permeanent log file(s) within the same loop.

This 'loop' could also be a Tk event callback.

I hope the following (crude) code will demonstrate the idea.

#! perl -slw
use strict;
use threads qw[ yield ];
use Thread::Queue;

package Tie::Glob::Queue;

sub TIEHANDLE {
    my $class = shift;
    my $self = new Thread::Queue;
    return bless \$self, $class;
}

sub PRINT {
    my $Q = ${ shift() };
    $Q->enqueue( join( $, || '', @_ ) );
}

1;

package main;

our $TELNETS ||= 10;

my $threads : shared = 0;

sub telnets{
    { lock $threads; $threads++ }
    my $io = shift;
    for( 1 .. 5 ) {
        print $io threads->tid(), " : $_";
        select undef, undef, undef, rand 1;
    }
    { lock $threads; $threads--; }
}

my $Q = ${ tie *LOG, 'Tie::Glob::Queue' };

my @threads = map{ threads->create( \&telnets, \*LOG )->detach } 1 .. 
+$TELNETS;

yield while $threads < $TELNETS;

while( $threads ) {
    if( $Q->pending ) {
        print $Q->dequeue;
    }
    else{
        yield;
    }
}
[download]

The tie package will need filling out (probably by inheriting from Tie::StdHandle) and the telnets() sub is just a placeholder but the basic methodology is there.

I have looked over your code during the weekend. I understand the idea but not all the syntax though.
In our $TELNETS ||= 10;, what does " || " do?
And this: select undef, undef, undef, rand 1; ?
In $Q->enqueue( join( $, || '', @_ ) );, $ stands for the joining character and @_ is the arguments. But what is " || " and " '' " doing there?
I'm not lacy, just couldn't find that type of syntax in my Perl litterature. I have Perl CD bookshelf (E-book) and Perl-power (hardcopy) amongst other.

Other than that, it looks good. I have to inherit a skeleton class IO::Handle but leave the major methods blank. Hope telnet-socket only require writing to handle or this whole thing will not work easilly.
It will not work as good if telnet-socket is writing in char-by-char fashion instead of line-by-line. I can check that out later.

This is the behaviour I had in mind for the code your supplied:
I use the main (GUI) thread to create a tie to the thread::queue as you have done.
Main-thread starts a new telnet-thread and passes that tied queue. Telnet-thread creates a socket with logging to tied-filehandle. Then command-execution to the telnet-socket starts (and later ends) while logging occur.
Main-thread then starts a Update-thread that uses the tied-handle to save logging to file and calls a callback function that output the logging to the right GUI window.
For that to work, all the telnet threads must print tagged-messages to tied-handle so I can separate them in my Update()-thread and output them to the right file and window.

So my program will have.

• a Main-thread that handles GUI and user input
• a Update-thread that updates GUI-window(s) and file(s) with telnet-traffic.
• 1..n, Telnet-threads that connects and executes commands on various hardware devices.

Main-thread may start another telnet-thread when user gives some appropriate GUI command. (So they don't start at the same time). The number of telnet-threads is limited by the number of hardware access points.


This is not so different to your behaviour description and it looks promising. By the way, I got the message "A thread exited while 2 threads were running." while I ran your code. It was not an error so I was not to bad.
Thanks, for redirecting me. Hope it works out for me now :)