El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Tasques i Concurrència

Següent ►
►

En aquest tema, explorarem la concurrència en Ada, un dels aspectes més potents i distintius del llenguatge. Ada proporciona mecanismes robustos per a la programació concurrent, permetent la creació de programes que poden executar múltiples tasques simultàniament. Aquestes capacitats són especialment útils en sistemes en temps real i aplicacions que requereixen un alt rendiment.

Continguts

  1. Introducció a les Tasques en Ada
  2. Creació i Gestió de Tasques
  3. Comunicació entre Tasques
  4. Sincronització de Tasques
  5. Exemples Pràctics
  6. Exercicis Pràctics

  1. Introducció a les Tasques en Ada

En Ada, una tasca és una unitat d'execució concurrent. Les tasques poden executar-se en paral·lel, permetent que diferents parts d'un programa es processin simultàniament. Això és especialment útil en aplicacions que necessiten realitzar múltiples operacions al mateix temps, com ara sistemes de control en temps real.

Conceptes Clau

  • Tasques: Unitats d'execució concurrent.
  • Concurrència: Capacitat d'executar múltiples tasques simultàniament.
  • Sincronització: Coordinació de l'execució de tasques per evitar conflictes.

  1. Creació i Gestió de Tasques

Declaració de Tasques

Per declarar una tasca en Ada, utilitzem la paraula clau task. Aquí teniu un exemple bàsic:

task type Worker is
    entry Start;
end Worker;

En aquest exemple, hem declarat un tipus de tasca anomenat Worker amb una entrada Start.

Implementació de Tasques

Després de declarar una tasca, hem d'implementar el seu cos:

task body Worker is
begin
    accept Start do
        -- Codi de la tasca
    end Start;
end Worker;

Creació d'Instàncies de Tasques

Per crear una instància d'una tasca, simplement declarem una variable del tipus de tasca:

My_Worker : Worker;

  1. Comunicació entre Tasques

Ada proporciona mecanismes per a la comunicació entre tasques mitjançant entrades i acceptacions. Les entrades permeten que una tasca esperi fins que una altra tasca li enviï un missatge.

Exemple de Comunicació

task type Sender is
    entry Send_Message (Msg : in String);
end Sender;

task body Sender is
begin
    accept Send_Message (Msg : in String) do
        -- Processar el missatge
    end Send_Message;
end Sender;

task type Receiver is
end Receiver;

task body Receiver is
    My_Sender : Sender;
begin
    My_Sender.Send_Message("Hola, món!");
end Receiver;

En aquest exemple, la tasca Receiver envia un missatge a la tasca Sender mitjançant l'entrada Send_Message.

  1. Sincronització de Tasques

La sincronització és crucial per evitar conflictes quan múltiples tasques accedeixen a recursos compartits. Ada proporciona diversos mecanismes per a la sincronització, com ara les barreres i els objectes protegits.

Exemple de Sincronització amb Barreres

task type Sync_Task is
    entry Wait_For_Others;
end Sync_Task;

task body Sync_Task is
begin
    accept Wait_For_Others;
    -- Codi que s'executa després de la sincronització
end Sync_Task;

  1. Exemples Pràctics

Exemple 1: Tasques Simples

with Ada.Text_IO; use Ada.Text_IO;

task type Simple_Task is
    entry Start;
end Simple_Task;

task body Simple_Task is
begin
    accept Start do
        Put_Line("Tasques en execució!");
    end Start;
end Simple_Task;

procedure Main is
    My_Task : Simple_Task;
begin
    My_Task.Start;
end Main;

Exemple 2: Comunicació entre Tasques

with Ada.Text_IO; use Ada.Text_IO;

task type Communicator is
    entry Send_Message (Msg : in String);
end Communicator;

task body Communicator is
begin
    accept Send_Message (Msg : in String) do
        Put_Line("Missatge rebut: " & Msg);
    end Send_Message;
end Communicator;

procedure Main is
    My_Communicator : Communicator;
begin
    My_Communicator.Send_Message("Hola, Ada!");
end Main;

  1. Exercicis Pràctics

Exercici 1: Crear una Tasca Simple

Descripció: Crea una tasca que imprimeixi un missatge quan s'inicia.

Solució:

with Ada.Text_IO; use Ada.Text_IO;

task type My_Task is
    entry Start;
end My_Task;

task body My_Task is
begin
    accept Start do
        Put_Line("Tasques en execució!");
    end Start;
end My_Task;

procedure Main is
    Task_Instance : My_Task;
begin
    Task_Instance.Start;
end Main;

Exercici 2: Comunicació entre dues Tasques

Descripció: Crea dues tasques, una que enviï un missatge i una altra que el rebi i l'imprimeixi.

Solució:

with Ada.Text_IO; use Ada.Text_IO;

task type Sender is
    entry Send_Message (Msg : in String);
end Sender;

task body Sender is
begin
    accept Send_Message (Msg : in String) do
        Put_Line("Missatge rebut: " & Msg);
    end Send_Message;
end Sender;

task type Receiver is
end Receiver;

task body Receiver is
    My_Sender : Sender;
begin
    My_Sender.Send_Message("Hola, món!");
end Receiver;

procedure Main is
    Receiver_Instance : Receiver;
begin
    null;
end Main;

Conclusió

En aquesta secció, hem après els conceptes bàsics de les tasques i la concurrència en Ada. Hem vist com crear i gestionar tasques, com comunicar-se entre elles i com sincronitzar-les. Aquests conceptes són fonamentals per a la programació concurrent i en temps real, i proporcionen una base sòlida per a desenvolupar aplicacions complexes i eficients.

En el proper tema, explorarem els objectes protegits, que ens permetran gestionar la concurrència de manera més segura i eficient.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats