ada
Tâche

Syntaxe

• tâche nom_tâche;
• task TaskName est la fin des entrées;
• le corps de la tâche Task_Name est les déclarations commencent fin du code;

Une tâche simple

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
   task My_Task;
   task body My_Task is
   begin
      Put_Line ("Hello from My_Task");
   end;
begin
   Put_Line ("Hello from Main");
end;

Résultat

L'ordre de Put_Line peut varier.

Hello from My_Task
Hello from Main

Une tâche simple et une boucle

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
   task My_Task;
   task body My_Task is
   begin
      for I in 1 .. 4 loop
         Put_Line ("Hello from My_Task");
      end loop;
   end;
begin
   Put_Line ("Hello from Main");
end;

Résultat

L'ordre de Put_Line peut varier.

Hello from My_Task
Hello from Main
Hello from My_Task
Hello from My_Task
Hello from My_Task

Une tâche simple et deux boucles

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
   task My_Task;
   task body My_Task is
   begin
      for I in 1 .. 4 loop
         Put_Line ("Hello from My_Task");
      end loop;
   end;
begin
   for I in 1 .. 4 loop
      Put_Line ("Hello from Main");
   end loop;
end;

Résultat

L'ordre de Put_Line peut varier.

Hello from My_Task
Hello from My_Task
Hello from Main
Hello from My_Task
Hello from Main
Hello from My_Task
Hello from Main
Hello from Main

Deux tâches simples et deux boucles

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
   task My_Task_1;
   task My_Task_2;
   
   task body My_Task_1 is
   begin
      for I in 1 .. 4 loop
         Put_Line ("Hello from My_Task_1");
      end loop;
   end;
   
   task body My_Task_2 is
   begin
      for I in 1 .. 4 loop
         Put_Line ("Hello from My_Task_2");
      end loop;
   end;
begin
   null;
end;

Résultat

L'ordre de Put_Line peut varier.

Hello from My_Task_1
Hello from My_Task_1
Hello from My_Task_2
Hello from My_Task_1
Hello from My_Task_2
Hello from My_Task_1
Hello from My_Task_2
Hello from My_Task_2

Une tâche qui incrémente un nombre après la saisie

L'utilisateur peut appeler le nombre de fois Incrementor.Increment K en appuyant sur une touche dans '0' .. '9' et il est possible d'appeler Incrementor.Increment plus rapidement que la task Incrementor peut incrémenter I

with Ada.Text_IO;
with Ada.Integer_Text_IO;

procedure Main is
   use Ada.Text_IO;
   task Incrementor is
      entry Increment;
   end;
   task body Incrementor is
      use Ada.Integer_Text_IO;
      I : Integer := 0;
   begin
      loop
         accept Increment;
         I := I + 1;
         Put (I, 0);
         delay 0.1;
      end loop;
   end;
   K : Character;
begin
   loop
      Get_Immediate (K);
      if K in '0' .. '9' then
         for I in 1 .. Natural'Value (K & "") loop
            Incrementor.Increment;
         end loop;
      end if;
   end loop;
end;

Interruption de la manipulation

Les interruptions sont gérées par une procédure protégée sans paramètres.

------------------------------------------------------------------
-- Interrupt Counting Package --
------------------------------------------------------------------
with Ada.Interrupts.Names; use Ada.Interrupts.Names;

package Ctl_C_Handling is

   protected CTL_C_Handler is
      procedure Handle_Int with
        Interrupt_Handler,
        Attach_Handler => SIGINT;
      entry Wait_For_Int;
   private
      Pending_Int_Count : Natural := 0;
   end Ctl_C_Handler;

   task CTL_Reporter is
      entry Stop;
   end CTL_Reporter;

end Ctl_C_Handling;

Le corps du package montre le fonctionnement de la procédure protégée. Dans ce cas, un booléen n'est pas utilisé dans l'objet protégé car les interruptions arrivent plus rapidement qu'elles ne sont traitées. La tâche CTL_Reporter gère les interruptions reçues.

with Ada.Text_IO; use Ada.Text_IO;
with Ctl_C_Handling; use CTL_C_Handling;
with Ada.Calendar; use Ada.Calendar;

package body Ctl_C_Handling is

   -------------------
   -- CTL_C_Handler --
   -------------------

   protected body CTL_C_Handler is

      ----------------
      -- Handle_Int --
      ----------------

      procedure Handle_Int is
      begin
         Pending_Int_Count := Pending_Int_Count + 1;
      end Handle_Int;

      ------------------
      -- Wait_For_Int --
      ------------------

      entry Wait_For_Int when Pending_Int_Count > 0 is
      begin
         Pending_Int_Count := Pending_Int_Count - 1;
      end Wait_For_Int;

   end CTL_C_Handler;

   ------------------
   -- CTL_Reporter --
   ------------------

   task body CTL_Reporter is
      type Second_Bin is mod 10;
      type History is array(Second_Bin) of Natural;

      ---------------------
      -- Display_History --
      ---------------------

      procedure Display_History(Item : History) is
         Sum : Natural := 0;
      begin
         for I in Item'Range loop
            Put_Line("Second: " & Second_Bin'Image(I) & " :" & Natural'Image(Item(I)));
            Sum := Sum + Item(I);
         end loop;
         Put_Line("Total count: " & Natural'Image(Sum));
         New_Line(2);
      end Display_History;

      One_Second_Count : Natural := 0;
      Next_Slot : Second_Bin := 0;
      Next_Second : Time := Clock + 1.0;
      Ten_Second_History : History := (Others => 0);

   begin
      loop
         Select
            Accept Stop;
            exit;
         else
            select
               CTL_C_Handler.Wait_For_Int;
               One_Second_Count := One_Second_Count + 1;
            or
               delay until Next_Second;
               Next_Second := Next_Second + 1.0;
               Ten_Second_History(Next_Slot) := One_Second_Count;
               Display_History(Ten_Second_History);
               Next_Slot := Next_Slot + 1;
               One_Second_Count := 0;
            end Select;
         end Select;
      end loop;
   end CTL_Reporter;
end Ctl_C_Handling;

Un exemple de programme principal pour exercer ce paquet est:

------------------------------------------------------------------
-- Ada2012 Interrupt Handler Example --
------------------------------------------------------------------
with Ada.Text_IO; use Ada.Text_IO;
with Ctl_C_Handling; use CTL_C_Handling;

procedure Interrupt01 is
begin
   Delay 40.0;
   CTL_Reporter.Stop;
   Put_Line("Program ended.");
end Interrupt01;