Ada 重新开始任务

我最近开始了Ada编程，现在我陷入了困境。 我创建了一个包含多个任务的程序。主要任务是管理传入的通信，因此启动工作任务或将数据传输到工作任务。 工作任务都是相同的类型，但标识符不同。 他们做他们的工作，然后应该完成。例如：

任务体访问\u受保护
开始
接受开始（foo:in整数；foo2:out整数）
做点什么
结束-开始；
边走边转
挑选
接受放弃做
Go_循环：=假；
结束退出；
或
接受插入（foo3：整数）
做点什么
如果某物=0，那么
Go_循环：=假；
如果结束；
端部插入件；
或延迟2.0；
终端选择；
端环；
终端访问受保护；

我理解工作任务应该在Go_循环完成时终止。我说得对吗？ 它可以一次启动任务，但当主任务试图通过调用启动过程来重新启动工作任务时，什么也不会发生。

---

有人能告诉我我遗漏了哪一点吗。

一个任务只会运行到其主要语句序列的末尾（忽略各种技术细节）

---

如果希望任务执行某项操作，然后暂停直到收到外部触发器，则应在任务正文中的语句周围放置一个循环。

任务只运行到其主要语句序列的末尾（忽略各种技术细节）

---

如果你想让一个任务做点什么，然后暂停直到它收到一个外部触发器，你应该在任务正文中的语句周围放一个循环。

a

task

和子程序有些关联，当正文完成时，构造结束，也就是说，构造以适当的

end

结束；在

过程

控制返回调用方的情况下，在

函数

的情况下，引发异常

程序错误

，在

任务

的情况下，控制“线程”终止

在你的特殊问题中发生了什么，似乎可以归结为以下几点：

Package Example is
    Task Type Message_Task is
        Entry Execute;
    End Message_Task;
End Example;

Package Body Example is
    Task Body Message_Task is
        Use Ada.Text_IO;
    Begin
        accept Execute  do
            Put_Line( "Rendezvous!" );
        end Execute;
        delay 0.2; -- Stub delay.
        Put_Line( "Finishing Task." );
        -- Task Ends Here.
    End Message_Task;
End Example;

--...
Test : Example.Message_Task;
--...

Test.Execute;
-- Test.Execute can't be accepted here because it can only accept "Execute"
-- the one time, as per the body's definition.

这个与您的问题类似的原因是，同样地，一旦您说“

X.Start（1,2）

”，另一个调用

Start

不会将任务的执行位置重置回该接受位置

如果希望任务“保持活动状态”以进行进一步处理，可以选择两种方法之一

选项1--设置“协议”：

Package Example is
    Task Type Message_Task is
        Entry Initialization;
        Entry Execute;
        Entry Quit;
    End Message_Task;
End Example;

Package Body Example is
    Task Body Message_Task is
        Use Ada.Text_IO;
        Has_quit : Boolean := False;
    Begin
        Main:
        loop
            select
                accept Initialization  do
                    null;
                end Initialization;
                accept Execute  do
                    null;
                end Execute;
            or
                accept Quit do
                    Has_Quit := True;
                end Quit;
            end select;
            Exit Main when Has_Quit;
        end loop Main;
    End Message_Task;
End Example;

选项2——允许终止

Package Example is
    Task Type Message_Task is
        Entry Initialization;
        Entry Execute;
    End Message_Task;
End Example;

Package Body Example is
    Task Body Message_Task is
        Use Ada.Text_IO;
        Has_quit : Boolean := False;
    Begin
        accept Initialization  do
            null;
        end Initialization;

        Main:
        loop
            select
                accept Execute  do
                    null;
                end Execute;
            or
                terminate;
            end select;
        end loop Main;
    End Message_Task;
End Example;

---

细微的区别在于选项2去掉了

Quit

条目，允许任务“休息”在

terminate

选项上，而选项1在控制方面更为明确（在某些情况下是必需的），但是要求成对调用

初始化

和

执行

。

A

任务

和子程序在某种程度上是相关的，当主体完成时，构造结束，也就是说，构造以适当的

结束

结束；在

过程

控制返回调用方的情况下，在

函数

的情况下，引发异常

程序错误

，在

任务

的情况下，控制“线程”终止

在你的特殊问题中发生了什么，似乎可以归结为以下几点：

Package Example is
    Task Type Message_Task is
        Entry Execute;
    End Message_Task;
End Example;

Package Body Example is
    Task Body Message_Task is
        Use Ada.Text_IO;
    Begin
        accept Execute  do
            Put_Line( "Rendezvous!" );
        end Execute;
        delay 0.2; -- Stub delay.
        Put_Line( "Finishing Task." );
        -- Task Ends Here.
    End Message_Task;
End Example;

--...
Test : Example.Message_Task;
--...

Test.Execute;
-- Test.Execute can't be accepted here because it can only accept "Execute"
-- the one time, as per the body's definition.

这个与您的问题类似的原因是，同样地，一旦您说“

X.Start（1,2）

”，另一个调用

Start

不会将任务的执行位置重置回该接受位置

如果希望任务“保持活动状态”以进行进一步处理，可以选择两种方法之一

选项1--设置“协议”：

Package Example is
    Task Type Message_Task is
        Entry Initialization;
        Entry Execute;
        Entry Quit;
    End Message_Task;
End Example;

Package Body Example is
    Task Body Message_Task is
        Use Ada.Text_IO;
        Has_quit : Boolean := False;
    Begin
        Main:
        loop
            select
                accept Initialization  do
                    null;
                end Initialization;
                accept Execute  do
                    null;
                end Execute;
            or
                accept Quit do
                    Has_Quit := True;
                end Quit;
            end select;
            Exit Main when Has_Quit;
        end loop Main;
    End Message_Task;
End Example;

选项2——允许终止

Package Example is
    Task Type Message_Task is
        Entry Initialization;
        Entry Execute;
    End Message_Task;
End Example;

Package Body Example is
    Task Body Message_Task is
        Use Ada.Text_IO;
        Has_quit : Boolean := False;
    Begin
        accept Initialization  do
            null;
        end Initialization;

        Main:
        loop
            select
                accept Execute  do
                    null;
                end Execute;
            or
                terminate;
            end select;
        end loop Main;
    End Message_Task;
End Example;

---

细微的区别在于选项2去掉了

Quit

条目，允许任务“休息”在

terminate

选项上，而选项1在控制方面更为明确（在某些情况下是必需的），但是要求成对调用

初始化

和

执行

。

在第一次执行后，是否无法重新启动任务？我不想把cpu时间浪费在暂停的任务上。任务应该完成他的工作，完成并在一段时间后重新开始。但是您可以有一个任务类型，并根据需要创建该类型的新任务。等待任务不使用CPU，所以我的建议很难说是浪费CPU时间。感谢您的帮助在第一次执行后，是否无法重新启动任务？我不想把cpu时间浪费在暂停的任务上。任务应该完成他的工作，完成并在一段时间后重新开始。但是您可以有一个任务类型，并根据需要创建该类型的新任务。等待任务不使用CPU，所以我的建议很难说是浪费CPU时间。谢谢你的帮助