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

Sincronització i Comunicació

Següent ►
►

En aquest tema, explorarem els conceptes de sincronització i comunicació en Ada, especialment en el context de la programació concurrent. Ada proporciona mecanismes robustos per gestionar la concurrència, permetent als programadors escriure aplicacions segures i eficients.

Conceptes Clau

  1. Tasques: Unitat bàsica de concurrència en Ada.
  2. Objectes Protegits: Mecanisme per a la sincronització i comunicació segura entre tasques.
  3. Entrades i Sortides Protegides: Mètodes per gestionar l'accés a recursos compartits.
  4. Rendezvous: Mecanisme de comunicació directa entre tasques.

Objectes Protegits

Els objectes protegits són una característica clau d'Ada per a la sincronització i la comunicació entre tasques. Proporcionen una manera segura de compartir dades entre tasques sense necessitat de bloquejos explícits.

Definició d'un Objecte Protegit

protected type Shared_Data is
   procedure Write(Value : Integer);
   function Read return Integer;
private
   Data : Integer := 0;
end Shared_Data;

protected body Shared_Data is
   procedure Write(Value : Integer) is
   begin
      Data := Value;
   end Write;

   function Read return Integer is
   begin
      return Data;
   end Read;
end Shared_Data;

Explicació

  • Declaració: protected type Shared_Data defineix un tipus protegit amb una interfície pública (procediments i funcions) i una part privada (dades compartides).
  • Implementació: El cos de l'objecte protegit implementa els procediments i funcions declarats.

Rendezvous

El rendezvous és un mecanisme de comunicació directa entre tasques en Ada. Permet que una tasca cridi una entrada d'una altra tasca, esperant fins que l'altra tasca estigui preparada per acceptar la crida.

Exemple de Rendezvous

task type Server is
   entry Request(Value : Integer);
end Server;

task body Server is
begin
   loop
      accept Request(Value : Integer) do
         -- Processar la sol·licitud
         Put_Line("Request received: " & Integer'Image(Value));
      end Request;
   end loop;
end Server;

task body Client is
begin
   Server.Request(42);
end Client;

Explicació

  • Declaració: task type Server defineix una tasca amb una entrada Request.
  • Acceptació: accept Request(Value : Integer) permet que la tasca Server accepti una crida de la tasca Client.
  • Crida: Server.Request(42) és la crida de la tasca Client a l'entrada Request de la tasca Server.

Exercicis Pràctics

Exercici 1: Sincronització amb Objectes Protegits

Descripció: Implementa un objecte protegit que permeti a múltiples tasques incrementar un comptador de manera segura.

Codi Inicial:

protected type Counter is
   procedure Increment;
   function Value return Integer;
private
   Count : Integer := 0;
end Counter;

protected body Counter is
   procedure Increment is
   begin
      Count := Count + 1;
   end Increment;

   function Value return Integer is
   begin
      return Count;
   end Value;
end Counter;

Solució:

task type Worker(C : in out Counter) is
end Worker;

task body Worker is
begin
   for I in 1 .. 100 loop
      C.Increment;
   end loop;
end Worker;

Counter_Instance : Counter;
Workers : array(1 .. 10) of Worker(Counter_Instance);

begin
   -- Esperar que totes les tasques acabin
   null;
end;

Exercici 2: Comunicació amb Rendezvous

Descripció: Implementa un sistema on una tasca Producer envia dades a una tasca Consumer utilitzant el mecanisme de rendezvous.

Codi Inicial:

task type Producer is
   entry Send_Data(Value : Integer);
end Producer;

task type Consumer is
   entry Receive_Data(Value : out Integer);
end Consumer;

Solució:

task body Producer is
begin
   for I in 1 .. 10 loop
      Consumer.Receive_Data(I);
   end loop;
end Producer;

task body Consumer is
   Value : Integer;
begin
   loop
      accept Receive_Data(Value : out Integer) do
         -- Processar la dada
         Put_Line("Data received: " & Integer'Image(Value));
      end Receive_Data;
   end loop;
end Consumer;

Errors Comuns i Consells

  1. Bloqueig Mutu: Assegura't que les tasques no es bloquegin mútuament esperant recursos que mai es desbloquejaran.
  2. Condicions de Carrera: Utilitza objectes protegits per evitar condicions de carrera quan múltiples tasques accedeixen a dades compartides.
  3. Rendiment: Evita l'ús excessiu de rendezvous, ja que poden introduir despeses de sincronització significatives.

Resum

En aquesta secció, hem explorat els mecanismes de sincronització i comunicació en Ada, incloent objectes protegits i rendezvous. Aquests conceptes són fonamentals per escriure aplicacions concurrents segures i eficients. Hem proporcionat exemples pràctics i exercicis per reforçar els conceptes apresos. En el proper tema, aprofundirem en la gestió d'excepcions en Ada.

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