冻结 Ada 任务

Question

如何冻结任务？

我的意思是，如果我有一个任务

task body My_Task is
begin 
  accept Start;
  loop
    Put ("1");
    Put ("2");
    Put ("3");
    ...
    Put ("n");
  end loop;
end My_Task;

，有没有办法可以将任务“冻结”在当前状态？例如，如果执行完成了 Put ("2");，我如何冻结它并稍后可以将其继续？我想从任务外部引发冻结，并从外部命令它继续。

更新

这样的规范，我肯定可以实现，

type State_Type is
  (RUN,
   FROZEN);

task type My_Task (State : State_Type) is
   entry Start;
end My_Task;

如果我有像正文

task body My_Task is
begin 
  accept Start;
  loop
    Put ("1");
    Put ("2");
    Put ("3");
    ...
    Put ("n");

    loop 
     if State = RUN then exit; end if;
    end loop;
  end loop;
end My_Task;

但事实并非如此，因为我必须等待第 n 个 Put 指令行（即，任务实际上不会被冻结，因为内部循环将会运行）。

Answer 1

您可以使用“选择性接受”来允许您的任务被外部调用者（另一个任务或主程序）中断。您不能（轻易）在任务执行过程中的任意时刻中断任务；相反，任务本身需要确定何时接受进入调用。

因此，您可能希望

Put("1");
Put("2");
Put("3");
...
Put("n");

用一个循环替换您的序列，该循环在每次迭代时调用一次 Put ，并每次都执行一个 select 语句。

这是我刚刚编写的一个演示程序。计数器每秒（大约）递增一次。如果 Running 为 true，则打印计数器值；否则循环会默默地进行。主程序每 3 秒交替调用 Pause 和 Resume。

如果两个条目都没有被调用，select 语句中的 else 子句会导致它继续执行。

with Ada.Text_IO; use Ada.Text_IO;
procedure T is

    task Looper is
        entry Pause;
        entry Resume;
    end Looper;

    task body Looper is
        Running: Boolean := True;
        Count: Integer := 0;
    begin
        loop
            select
                accept Pause do
                    Running := False;
                end;
            or
                accept Resume do
                    Running := True;
                end;
            else
                null;
            end select;
            delay 1.0;
            if Running then
                Put_Line("Running, Count = " & Integer'Image(Count));
            end if;
            Count := Count + 1;
        end loop;
    end Looper;

begin -- T
    loop
        delay 3.0;
        Looper.Pause;
        delay 3.0;
        Looper.Resume;
    end loop;
end T;

可能还有比这更优雅的方法。已经很久没有真正使用过Ada了。

Answer 2

哇，好久没看到艾达的问题了。无论如何，每当您需要暂停任务时，您都可以使用“延迟”或“延迟直到”保留字。

您可以指定要恢复执行的时间，然后说：

延迟<时间>

或

延迟直到<时间>

我不记得确切的细节，但是这是 Ada95 规范示例： http://www.adaic.org/resources/add_content/docs/95style/html/sec_6/6-1-7.html

Answer 3

Ada 语言的设计意图之一是行为是明确的。一项正在执行的任务突然发现自己由于没有明显原因而“冻结”在任意点（任务中没有任何内容会导致该行为），充其量只会令人不安。如果任务的设计不允许意外的、任意的执行暂停，则可能是一个错误。 （我知道操作系统时间切片将这种行为强加于执行程序，但这是操作系统的功能，而不是编程语言的功能。）

简而言之，我会严重质疑依赖外部强加的任务暂停的设计方法。任务应该知道它自己的状态，从而知道何时可以安全地暂停，以及暂停时必须保持哪些不变量以确保正确恢复。

Answer 4

为了获得正确中断 put("x") 序列所需的粒度，您应该将其编写为一个过程，将其状态保存在 task my_task 中（知道哪个原子指令已被执行）。

那么我想你可以在你的 State_Typeguard code> 并且仅在未冻结时执行。当然，这不会停止任务，它只会保护 put("x") 序列不被执行（我认为这就是你想要的！）

Answer 5

如果您总是希望任务在某一特定行等待，那么解决方案相当简单：只需在此处放置一条 accept 语句即可。该任务将挂起，直到其他任务调用该条目。

如果你想推广这个想法（这样可以让多个任务等待，或者多个不同的任务可以安全地执行释放操作），最好将你的 State 变量封装在受保护的对象中（正如国家气象局建议的那样）。受保护对象的功能被专门放入语言中，以方便为此类任务创建同步对象。

Answer 6

您在回复其中一条评论时提到，您希望这样做是因为有一些共享资源。那么，答案似乎是您想要将该共享资源包装在受保护对象中，并从任务中调用该受保护对象的过程/条目；当任务在受保护对象调用上排队（或执行）时，它会进入“阻塞”状态，直到它返回，从而“冻结”进一步的处理。

编辑：添加了代码示例。

---

With
Ada.Text_IO,
Ada.Strings.Fixed,
Ada.Numerics.Float_Random
;

with ada.Integer_Text_IO;
with Ada.Strings;

Use Ada.Numerics.Float_Random;
Procedure Experiment is

   Task Type Testing( Text : Not Null Access String ) is
      end Testing;

   protected Resource is
      procedure Write( Input : In String );
   private
   end Resource;

   Task Body Testing is
      G : Ada.Numerics.Float_Random.Generator;
      D : Duration := Duration( Random(G) );
   Begin
      delay  D;
      Resource.Write( Text.ALL );
   End Testing;

   protected body Resource is
      procedure Write( Input : In String ) is
      begin
         Ada.Text_IO.Put_Line( Input );
      end Write;

   end Resource;

   Function Make(Input : in String) Return Access Testing is
   begin
      Return Result : Access Testing:= New Testing( New String'(Input) );
   end Make;


   TaskList : Array (Positive Range <>) of Access Testing:=
     ( Make("Anger"), Make("Rage"), Make("Joy"), Make("Contentment") );
  Use Ada.Text_IO;
Begin

   Put_Line( "Terminating." );

End Experiment;

---

注意： put_line 的使用在技术上不是线程安全的，并且 [IIRC] 可能会阻塞......因此，虽然上述内容永远不会死锁，但实际上并不能保证。

Answer 7

我还从 Anh Vo in comp.lang.ada 得到了答案（冻结任务），其中还包括带有任务终止的 Rendevouz。经过一些调整，它得到：

task type My_Task is
   entry Start;
   entry Pause;
   entry Quit;
   entry Stop;
end My_Task;

-- (...)
task body My_Task is
begin
   Outer_Loop : loop
      select
         accept Start;

         Main_Loop : loop
            select
               accept Pause;

               select
                  accept Quit;
               or
                  accept Stop;
                  exit Outer_Loop;
               or
                  terminate;
               end select;
            or
               accept Stop;
               exit Outer_Loop;
            else
               Put ("Main code here");
               delay MYCYCLE; -- MYCYCLE is 2.0; (whatever)
            end select;
         end loop Main_Loop;
      or
         terminate;
      end select;
  end loop Outer_Loop;
end My_Task;

我承认我认为这个解决方案非常优雅。