Perl 多个子例程

Question

对于 perl 专家来说，这可能是一个简单的问题 -

我正在尝试运行一个在逻辑上应该执行此操作的脚本>

Main
{
 While (true)
  Call Sub A
  Call Sub B
  Call Sub C
}

Sub A
{
Go execute a method A for whatever it needs to do ---
before next time method A runs it need to wait atleast 60 seconds but i still want to call method B in these 60 seconds.
}

Sub B
{
  Go execute a method B for whatever it needs to do ---
before next time method b runs it need to wait atleast 60 seconds but i still want to call method C in these 60 seconds in mean time.

}

Sub C
{
  Go execute a method C for whatever it needs to do ---
before next time method C runs it need to wait atleast 60 seconds at this moment control should be back in Main and wait for first 60 seconds of A to expire so that Sub A can be called
}

我的问题： 问：我能做到这一点的最佳和优化方式是什么？

问：如果我在每个 sub 中设置 sleep 60，那么即使在 60 秒到期之前，下一个 sub 也不会被调用，这将延迟整体处理。

问：我希望每 60 秒按顺序调用 3 个潜艇

Q 最后，如果我需要每 60 秒呼叫 2 个 subs 并且每小时最后一个 subs - 我该怎么做？

评论 - 我的想法是将 UTC 作为一个变量并将其存储在一个变量中，并在时间到期时继续检查时间，而不是调用单个潜艇，但不确定它是否是运行代码的最佳方式。

Answer 1

在子程序内部记录它最后一次运行的时间，如果需要，等待下一次执行：

use feature 'state';

my $sleep_duration = 60; # seconds

sub foo {
   state $last_execution = 0;
   my $remaining = $last_execution + $sleep_duration - time;
   sleep $remaining if $remaining > 0;
   $last_execution = time;

   ...; # normal processing for this sub
}

Answer 2

您可能想use threads。下面的 sn-p 可能会给你一个起点。由于您有四个 Qs 而不是一个，因此我不会详细介绍它们。

#!/usr/bin/perl

use warnings;
use strict;
use threads;

my @t = (
  threads->create(\&A),
  threads->create(\&B),
  threads->create(\&C)
);

$t[0] -> join();
$t[1] -> join();
$t[2] -> join();

sub A {
  for my $i (1 .. 10) {
     print "A $i\n";
     sleep 60;
  }
}

sub B {
  for my $i (1 .. 20) {
     print "B $i\n";
     sleep 60;
  }
}

sub C {
  for my $i (1 .. 3) {
     print "C $i\n";
     sleep 60;
  }
}

Answer 3

使用 Amon 的思想，但在函数外有睡眠逻辑，

sub get_sleeper {

  my ($sleep_duration) = @_;

  my $last_execution = 0;
  return sub {
    my $remaining = $last_execution + $sleep_duration - time();
    sleep $remaining if $remaining >0;
    $last_execution = time();
  };
}

my ($sleepA, $sleepB, $sleepC) = map get_sleeper(60), 1..3;
while (1) {
  $sleepA->(); SubA();
  $sleepB->(); SubB();
  $sleepC->(); SubC();
}

Answer 4

这两个答案都很好，但一种中间方法是：（从 amon 的答案中窃取）

use feature 'state';

my $sleep_duration = 60; # seconds

sub foo {
   state $last_execution = 0;
   my $remaining = $last_execution + $sleep_duration - time;
   if ($remaining > 0)
   {
       return "Waiting";  # Make sure main checks for this to know whether the sub ran.
   }

   ...; # normal processing for this sub
}

这将允许您在这个等待时运行下一个子而不需要多个线程。但当然，这意味着这艘潜艇只有在其他两个有机会之后才会运行。这意味着您混淆了订单，并根据订阅者的不同，需要超过 60 秒的时间才能进行下一次通话。