What else can i do 'sleep' when the sleep(

问题:

There are many documents say "you should avoid using sleep with alarm, since many systems use alarm for the sleep implementation". And actually, I'm suffering with this problem. So does anyone can help me that what else i can do 'sleep' when the sleep() can't work well with alarm? I have already tried 'usleep' of the Time::HiRes module, and select() function. But they didn't work either.

回答1:

You can try AnyEvent:

use AnyEvent;

my $cv = AnyEvent->condvar;
my $wait_one_and_a_half_seconds = AnyEvent->timer(
    after => 1.5,
    cb => sub { $cv->send }
);     
# now wait till our time has come
$cv->recv;

回答2:

Seeing as you're being interrupted by alarms, and so can't reliably use sleep() or select(), I suggest using Time::HiRes::gettimeofday in combination with select().

Here's some code that I've not tested. It should resist being interrupted by signals, and will sleep for the desired number of seconds plus up to 0.1 seconds. If you're willing to burn more CPU cycles doing nothing productive, you can make the resolution much better:

...
alarm_resistant_sleep(5); # sleep for 5 seconds, no matter what
...

use Time::HiRes;

sub alarm_resistant_sleep {
  my $end = Time::HiRes::time() + shift();
  for (;;) {
    my $delta = $end - Time::HiRes::time();
    last if $delta <= 0;
    select(undef, undef, undef, $delta);
  }
}

回答3:

You can sleep on a new process via system:

system ( "sleep", 5 );

Or did I misunderstand the question?

回答4:

When using (from MySQL forum)

use Sys::SigAction qw( set_sig_handler );
eval {
  my $hsig = set_sig_handler( 'ALRM', sub { my $canceled = 1; die; }, { mask=>[ qw( INT ALRM ) ] ,safe => 0 } );
  alarm($timeout);
  ...
  alarm(0);
}

I noticed that any subsequent calls made to sleep($delay) with $timeout shorter than $delay would end up with the script execution being terminated, and the print of "Alarm clock".

The workaround I've found is to call alarm() again but with an improbably large value (3600), and cancel that alarm right after.

eval {
  alarm(3600);
  print " .... Meeeep ....";  # Some trace
  alarm(0); 
};

Then I can use sleep() with no interference anymore.

Example below (live code snippet):

sub unmesswithsleep {
  eval {
    alarm(3600);
    &tracing (8, " .... Meeeep ....");
    alarm(0); 
  };
}


sub lockDBTables {
  return (0) unless ($isdbMySQLconnect);
  my $stm = qq {
    LOCK TABLES 
      myBIGtable WRITE
  };

  my $timeout = 60;          # This is the timer set to protect against deadlocks. Bail out then.
  eval { 
    my $h = set_sig_handler( 'ALRM', sub { my $canceled = 1; die; }, { mask=>[ qw( INT ALRM ) ] ,safe => 0 } ); 
    alarm($timeout); 
    my $res = $dbmyh->do($stm) + 0;
    alarm(0);  # Reset alarm
  };

  if ( $@ =~ m/Die/i ) {
    $isdbTabledlocked = 0;
    &tracerr (0, "FATAL: Lock on Tables has NOT been acquired within ${timeout}s. Lock is set to <$isdbTabledlocked>.");
    &unmesswithsleep();   # MUST be called each time alarm() is used
    return (0);
  } else { 
    $isdbTabledlocked = 1;
    &tracing (2, "  Good: Lock on Tables has been acquired in time. Lock is set to <$isdbTabledlocked>.");
    &unmesswithsleep();   # MUST be called each time alarm() is used
    return (1);
  }
  # Can use sleep() now.
}

回答5:

try

print "Start\n";
select undef, undef, undef, 1;
print "End\n";                                                                  

This will sleep for 1 second.

回答6:

It sounds like your code that sleeps is being interrupted by some code that sets an alarm. This is by design so you're seeing the expected behavior. In other words an alarm *should always interrupt a sleep call.

If you're looking for a pure perl way to sleep without being interrupted by an alarm you can do this by installing your own alarm signal handler. This way when your code gets an alarm it won't interrupt your processing.

However, an important caveat is that this will delay any alarm that was set by other code. The other code will receive the alarm late; after your code completes. This means that if you want to play well with others you're better off using one of the other solutions.

Here is an example:

#!/usr/bin/perl

use POSIX;
use strict;
use warnings;

# set an alarm
print "Setting alarm\n";
alarm 1;

my $old_alarm;
my $snoozed;
{
  # store the previous alarm handler (if any)
  $old_alarm = $SIG{ALRM};

  # override the alarm handler so that we don't
  # get interrupted
  local $SIG{ALRM} = sub {
    print "got alarm; snoozing\n";

    # record the fact that we caught an alarm so that
    # we can propagate it when we're done
    $snoozed++;
  };

  # sleep for a while.
  for (1 .. 3) {
    print "z" x $_ ,"\n";
    sleep 1;
  }
}

# replace the old sleep handler;
$SIG{ALRM} = $old_alarm
 if $old_alarm;

# if we had to snooze fire an immediate alarm;
if ($snoozed) {
  POSIX::raise(POSIX::SIGALRM);
}

The documentation you reference hints at but does not describe a different symptom. The main thing you need to worry about when sleep is implemented via alarm is having your alarm reset when someone calls sleep.

*Apparently there are some versions of perl (e.g.: old Win32) where an alarm doesn't interrupt sleep.