You can accomplish this in a much simpler way by setting some sort of cancel indication (a variable):

use Tk;
use Tk::ProgressBar;
use strict;
use warnings;

my $count;
my $cancel;

my $mw = new MainWindow(-title => "demo");
$mw->Button(-command => sub {do_something(\$count, \$cancel)}, -text =
+> "Do Something")->pack();
$mw->Button(-command => sub {cancel(\$cancel)}, -text => "Cancel")->pa
+ck();
my $pb = $mw->ProgressBar(
        -from => 0,
        -to => 100,
        -blocks => 100,
        -colors => [0, 'green', 50, 'yellow' , 80, 'red'],
        -variable => \$count
)->pack();
MainLoop;

sub do_something {
    my ($count_r, $cancel_r) = @_;
    $$count_r = 0;
    $$cancel_r = 0;

    while (!$$cancel_r & $$count_r < 100) {
        $$count_r ++;
        $mw->update();
        sleep(1);
    }
}

sub cancel {
    my $cancel_r = shift;
    $$cancel_r = 1;
}
[download]

One thing important here is to analyze your "unit of work". You only need to check cancel indication after the completion of each unit of work. This is safe and simple.

You can choose to check even during the unit of work, if your unit of work takes too long and you want a shorter response time. But you have to make sure the work can be fully cancelled, not leave something half broken there, and demage your data integrity.

Also if your unit of work is too big, you probably want to look at your analysis again.

#!/usr/bin/perl
use Tk; 
use strict; 
require Tk::ProgressBar; 
require Tk::Button; 
my ( 
    $mw, 
    $progressBar, 
    $cancelCalButton, 
    $runCalButton, 
   ); 
my $guiPid = $$; 
$mw = MainWindow->new(); 
$cancelCalButton = $mw->Button(-text=>"cancel")->pack(); 
$runCalButton = $mw->Button(-text=>"run",-command=>\&doit)->pack(); 
$progressBar = $mw->ProgressBar()->pack(); 
 my $val = 0;
$SIG{USR1} = sub { 
  $val = 0;
  $progressBar->value(0); 
  $mw->update(); 
  $runCalButton->configure(-state=>"normal"); 
  $cancelCalButton->configure(-state=>"disabled"); 
}; 
$SIG{USR2} = sub { 
    $val++;
    $progressBar->value($val*10); 
    $mw->update(); 
}; 
MainLoop; 
sub doit { 
  my $calPid; 
  $runCalButton->configure(-state=>"disabled"); 
  $cancelCalButton->configure(-state=>"normal"); 
  $mw->update; 
  print "Failed to fork" if (!defined($calPid = fork())); 
  return if ($calPid); 
  for (1 .. 10) { 
    $progressBar->value($_); 
    kill('USR2',$guiPid); 
    sleep(1) ;
  } 
  # send the signal to main GUI to reconfigure the button states 
  kill('USR1',$guiPid); 
  kill('INT',$$); 
}
[download]

I have tried this approach, but I still got the error (in a couple of different incarnations). If you ran yours, I wonder if maybe you didn't run it for long enough, because, based on what is written above, it is still unsafe due to asynchronous accesses.

I've ran it longer enough and I didn't have any problems with it. The trick is to have all the Tk/X operations {mw->update and so...) in a single process. Beside of USR1 and USR2, you can try to trapp different signals.
I know the aproach it's ugly, but for me it works just fine...

--------------------------------------
"Quoth The Raven Nevermore"
SleepNot a.k.a TheCount

use Tk;
use strict;
require Tk::ProgressBar;
require Tk::Button;

$|++;

my (
    $mw,
    $progressBar,
    $cancelCalButton,
    $runCalButton,
    $cancel,
   );

my @data = (0 .. 100);
my $dataIndex;

my $guiPid = $$;
my $childPid;

pipe(FROM_PARENT, TO_CHILD) or die "pipe: $!\n";
pipe(FROM_CHILD, TO_PARENT) or die "pipe: $!\n";
select((select(TO_CHILD), $| = 1)[0]);
select((select(TO_PARENT), $| = 1)[0]);

if ($childPid = fork()){
  close FROM_PARENT;
  close TO_PARENT;
} else {
  die "cannot fork :$!\n" unless defined $childPid;
  close FROM_CHILD;
  close TO_CHILD;
  while(my $line = <FROM_PARENT>){
    chomp($line);
    print "Chid got from parent $line\n";
    sleep(10);
    if ($line == 100){
      kill('USR1',$guiPid); #tell the GUI child is done with work
      next;
    }
    kill('USR2',$guiPid); #tell the GUI child has update info
    print "sending stuff to parent\n";
    print TO_PARENT "$line\n";
  }
  print "Done with child\n";
  exit();
}

$mw = MainWindow->new();
$cancelCalButton = $mw->Button(-text=>"cancel", -command=>\&cancel)->p
+ack();
$runCalButton = $mw->Button(-text=>"run",-command=>\&doit)->pack();
$progressBar = $mw->ProgressBar()->pack();
$mw->repeat(100,sub{$mw->idletasks});

$SIG{USR1} = sub {
  $cancel = 1;
  $progressBar->value(0);
  $cancelCalButton->configure(-state=>"disabled");
  $mw->idletasks;
};

$SIG{USR2} = sub {
  $runCalButton->configure(-state=>"normal");
  print "Got USR2 request\n";
  my $value = <FROM_CHILD>;
  print "parent got $value from child\n";
  return if ($cancel);
  $progressBar->value($value);
  $runCalButton->configure(-state=>"disabled");
  print TO_CHILD "$data[$dataIndex++]\n";
};

MainLoop;

sub doit {

  $runCalButton->configure(-state=>"disabled");
  $cancelCalButton->configure(-state=>"normal");
  $mw->update;
  $cancel = 0;
  $dataIndex = 0;
  print TO_CHILD "$data[$dataIndex++]\n";
}

sub cancel {
  print "@@@@@@@@@ Got Cancel button @@@@@@@@@\n";
  kill('USR1',$$);
}
[download]