The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Tasks and Concurrency

Next ►
►

Concurrency is a fundamental concept in modern programming, allowing multiple tasks to be executed simultaneously. Ada provides robust support for concurrent programming through its tasking model. In this section, we will explore the basics of tasks and concurrency in Ada, including how to create and manage tasks, synchronization mechanisms, and practical examples.

Key Concepts

  1. Tasks: Independent units of execution that can run concurrently with other tasks.
  2. Task Types: Define a blueprint for creating multiple tasks with similar behavior.
  3. Synchronization: Mechanisms to coordinate the execution of tasks, ensuring correct interaction.
  4. Protected Objects: Special constructs to safely share data between tasks.

Creating Tasks

In Ada, tasks are declared using the task keyword. Here is a simple example:

task My_Task is
end My_Task;

task body My_Task is
begin
   -- Task code goes here
   Ada.Text_IO.Put_Line("Hello from My_Task!");
end My_Task;

Explanation

  • Task Declaration: The task My_Task is line declares a task named My_Task.
  • Task Body: The task body My_Task is block contains the code that the task will execute.

Task Types

Task types allow you to create multiple instances of a task with the same behavior. Here is an example:

task type Worker is
end Worker;

task body Worker is
begin
   -- Task code goes here
   Ada.Text_IO.Put_Line("Hello from Worker!");
end Worker;

-- Creating multiple instances of Worker
Worker1 : Worker;
Worker2 : Worker;

Explanation

  • Task Type Declaration: The task type Worker is line declares a task type named Worker.
  • Task Type Body: The task body Worker is block contains the code that each instance of the task will execute.
  • Task Instances: Worker1 and Worker2 are instances of the Worker task type.

Synchronization

Synchronization is crucial in concurrent programming to avoid race conditions and ensure data consistency. Ada provides several mechanisms for synchronization, including rendezvous and protected objects.

Rendezvous

A rendezvous is a synchronization mechanism where one task waits for another to reach a specific point. Here is an example:

task Server is
   entry Start;
end Server;

task body Server is
begin
   accept Start do
      Ada.Text_IO.Put_Line("Server started!");
   end Start;
end Server;

task Client is
begin
   Server.Start;
end Client;

Explanation

  • Entry Declaration: The entry Start; line declares an entry point named Start in the Server task.
  • Accept Statement: The accept Start do block in the Server task body waits for the Client task to call the Start entry.
  • Client Task: The Client task calls the Start entry of the Server task, causing the Server to print "Server started!".

Protected Objects

Protected objects provide a safe way to share data between tasks. Here is an example:

protected 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;

task Writer is
begin
   Shared_Data.Write(42);
end Writer;

task Reader is
begin
   Ada.Text_IO.Put_Line("Data: " & Integer'Image(Shared_Data.Read));
end Reader;

Explanation

  • Protected Object Declaration: The protected Shared_Data is block declares a protected object with a procedure Write and a function Read.
  • Protected Object Body: The protected body Shared_Data is block defines the implementation of the Write procedure and Read function.
  • Writer Task: The Writer task writes the value 42 to the Shared_Data protected object.
  • Reader Task: The Reader task reads the value from the Shared_Data protected object and prints it.

Practical Exercise

Exercise

Create a simple Ada program with two tasks: one task that increments a shared counter and another task that reads and prints the counter value.

Solution

with Ada.Text_IO; use Ada.Text_IO;

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

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

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

task Incrementer is
begin
   for I in 1 .. 10 loop
      Counter.Increment;
   end loop;
end Incrementer;

task Printer is
begin
   Ada.Text_IO.Put_Line("Counter value: " & Integer'Image(Counter.Get));
end Printer;

Explanation

  • Protected Object Counter: Manages a shared counter with an Increment procedure and a Get function.
  • Incrementer Task: Increments the counter 10 times.
  • Printer Task: Reads and prints the counter value.

Common Mistakes and Tips

  • Race Conditions: Ensure proper synchronization to avoid race conditions.
  • Deadlocks: Be cautious of deadlocks where tasks wait indefinitely for each other.
  • Task Termination: Ensure tasks terminate properly to avoid resource leaks.

Conclusion

In this section, we covered the basics of tasks and concurrency in Ada, including task creation, task types, synchronization mechanisms, and practical examples. Understanding these concepts is crucial for developing robust and efficient concurrent programs in Ada. In the next section, we will delve deeper into protected objects and their role in concurrent programming.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved