To use Tk and threads together, all your interaction with Tk objects *must* be from one thread only.

In the following code, the threads load the image data into shared buffers and then set a flag to indicate that the data is ready.

In the main thread, I've set up a repeating callback that checks the flags and when set, does the steps necessary to load the new image into the gui.

I've simulated the network fetch by loading a randomly selected, suitably sized image from a directory, but all the principal steps remain:

• Do the slow stuff (network interaction or file loading) in the thread(s).
• Share the data through shared buffers with the main (Tk) thread.
• Use a callback in the main thread to update the gui.

To run this demo as is, create 4 directories (c:\test\pics\(one|two|three|four) in this example), and place a number of suitably sized jpgs in each directory.

#! perl -slw
use Tk;
#use Tk::X11Font;
use Tk::JPEG;
use LWP::UserAgent;
use MIME::Base64;
use IO::Socket;
use threads;
use threads::shared;

my $host = 'c:\test\pics'; ## Dummy 'host' for testing
my @urls = qw[ one two three four ]; ## Dummy 'urls' for testing

my @data  :shared = ('') x 4;   ## 4 shared image data buffers
my @flags :shared = (0) x 4;    ## 4 shared 'image ready' flags

sub loadJpg {
    my( $host, $url, $no, $dataref ) = @_;
    my @jpgs = glob "$host/$url/*.jpg";
    while( sleep 1+rand 4 ) { ## Simulate network delays
        next if $flags[ $no ];  ## If the flag is still set do nothing

        ## Load the image
        my $jpg = $jpgs[ rand @jpgs ]; 
        open my $fh, '<:raw', $jpg or warn "$jpg : $!" and next;
        my $data = do{ local $/; <$fh> };
        close $fh;

        ## copy to the appropriate shared buffer
        $dataref->[ $no ] = $data;

        ## Set the appropriate 'image ready' flag
        $flags[ $no ] = 1;
    }
}

## Start the threads passing 
## The host, url, buffer/flag number and buffer reference
my @threads = map{
    threads->new( \&loadJpg, $host, $urls[ $_ ], $_, \@data );
} 0 .. 3;

my $stop = 0;
my $mw = MainWindow->new(title=>"Cams");
$mw->minsize( qw(640 480));
my $top = $mw->Frame()->pack(-side=>'top');
my $bottom = $mw->Frame()->pack(-side=>'bottom');

## Use an array, indexed by passed number
my @photos =  (
    $top->Label()->pack(-side => 'left'),
    $top->Label()->pack(-side => 'right'),
    $bottom->Label()->pack(-side => 'left'),
    $bottom->Label()->pack(-side => 'right'),
);

$mw->Button(-text=>"Stop",-command => sub { $stop=1; })->pack();

## Set up a regular callback in the main thread that
## a) checks the flags for each image 
## and if it is set
## b) Locks the data
## c) Encodes the data
## d) Creates a Photo object from it
## e) Sets it into the widget
## f) Clears the flag ready for the next
$mw->repeat( 1000, sub{
    for my $n ( 0 .. 3 ) {
        if( $flags[ $n ] ) {
            lock( @data );
            my $data = encode_base64( $data[ $n ] );
            $image[ $n ]->delete if $image[ $n ];   ## Addendum: 
            $image[ $n ] = $mw->Photo( -format=>'jpeg', -data=>$data )
+;
            $photos[ $n ]->configure( -image => $image[ $n ] );
            $flags[ $n ] = 0;
        }
    }
} );

MainLoop;
[download]