ada
निर्माता-उपभोक्ता पैटर्न को लागू करना

परिचय

वाक्य - विन्यास

• फ़ंक्शन स्केलर की छवि (तर्क: स्केलर'बेस) रिटर्न स्ट्रिंग;
• कार्य Task_Name;
• कार्य Task_Name प्रविष्टि अंत है;
• टास्क बॉडी Task_Name घोषणाएं शुरू होती हैं कोड अंत;
• प्रविष्टि Entry_Name;
• Entry_Name स्वीकार करें;
• बाहर जाएं;

टिप्पणियों

एक सिंक्रनाइज़ बफर का उपयोग करना

with Ada.Containers.Synchronized_Queue_Interfaces;
with Ada.Containers.Unbounded_Synchronized_Queues;
with Ada.Text_IO;

procedure Producer_Consumer_V1 is
   type Work_Item is range 1 .. 100;

   package Work_Item_Queue_Interfaces is
     new Ada.Containers.Synchronized_Queue_Interfaces
           (Element_Type => Work_Item);

   package Work_Item_Queues is
     new Ada.Containers.Unbounded_Synchronized_Queues
           (Queue_Interfaces => Work_Item_Queue_Interfaces);

   Queue : Work_Item_Queues.Queue;

   task type Producer;
   task type Consumer;

   Producers : array (1 .. 1)  of Producer;
   Consumers : array (1 .. 10) of Consumer;

   task body Producer is
   begin
      for Item in Work_Item loop
         Queue.Enqueue (New_Item => Item);
      end loop;
   end Producer;

   task body Consumer is
      Item : Work_Item;
   begin
      loop
         Queue.Dequeue (Element => Item);
         Ada.Text_IO.Put_Line (Work_Item'Image (Item));
      end loop;
   end Consumer;

begin
   null;
end Producer_Consumer_V1;

ध्यान दें कि मैं यहाँ आलसी हो चुका हूँ: एक बार सभी कामों का उपभोग करने के बाद, उपभोक्ता कार्यों की कोई उचित समाप्ति नहीं होती है।

Ada Rendezvous तंत्र का उपयोग करते हुए निर्माता-उपभोक्ता पैटर्न

एक सिंक्रोनस प्रोड्यूसर-कंज्यूमर सॉल्यूशन यह सुनिश्चित करता है कि उपभोक्ता प्रोड्यूसर द्वारा लिखे गए हर डेटा आइटम को ठीक एक बार पढ़े। अतुल्यकालिक समाधान उपभोक्ता को निर्माता के उत्पादन का नमूना लेने की अनुमति देते हैं। या तो उपभोक्ता उत्पादित किए गए डेटा की तुलना में तेज़ी से खपत करता है, या उपभोक्ता उत्पादित किए गए डेटा की तुलना में धीमी खपत करता है। नमूनाकरण उपभोक्ता को वर्तमान में उपलब्ध डेटा को संभालने की अनुमति देता है। वह डेटा केवल उत्पादित डेटा का एक नमूना हो सकता है, या यह पहले से ही खपत डेटा हो सकता है।

------------------------------------------------------------------
-- synchronous PC using Rendezvous --
------------------------------------------------------------------
with Ada.Text_IO; use Ada.Text_IO;

procedure PC_Rendezvous is
   task Producer;
   task Consumer is
      entry Buf(Item : in Integer);
   end Consumer;
   task body Producer is
   begin
      for I in 1..10 loop
         Put_Line("Producer writing" & Integer'Image(I));
         Consumer.Buf(I);
      end loop;
   end Producer;
   task body Consumer is
      Temp : Integer;
   begin
      loop
         select
            accept Buf(Item : in Integer) do
               temp := Item;
            end;
            Put_Line("Consumer read" & Integer'Image(Temp));
         or
            terminate;
         end select;
      end loop;
   end Consumer;

begin
   null;
end PC_Rendezvous;

नमूना उपभोक्ता के साथ निर्माता-उपभोक्ता

यह उदाहरण निर्माता कार्य के रूप में मुख्य प्रक्रिया का उपयोग करता है। Ada में मुख्य प्रक्रिया हमेशा कार्यक्रम में अन्य सभी कार्यों से अलग कार्य में चलती है, न्यूनतम उदाहरण देखें ।

------------------------------------------------------------------
-- Sampling Consumer --
------------------------------------------------------------------
with Ada.Text_IO; use Ada.Text_IO;

procedure Sampling_PC is
   protected Buf is
      procedure Write(Item : in Integer);
      function Read return Integer;
      procedure Set_Done;
      function Get_Done return Boolean;
   private
      Value : Integer := Integer'First;
      Is_Done : Boolean := False;
   end Buf;
   protected body Buf is
      procedure Write(Item : in Integer) is
      begin
         Value := Item;
      end Write;
      function Read return Integer is
      begin
         return Value;
      end Read;
      procedure Set_Done is
      begin
         Is_Done := True;
      end Set_Done;
      function Get_Done return Boolean is
      begin
         return Is_Done;
      end Get_Done;
   end Buf;

   task Consumer;
   task body Consumer is
   begin
      while not Buf.Get_Done loop
          Put_Line("Consumer read" & Integer'Image(Buf.Read));
      end loop;
   end Consumer;

begin
   for I in 1..10 loop
     Put_Line("Producer writing" & Integer'Image(I));
     Buf.Write(I);
   end loop;
   Buf.Set_Done;
end Sampling_PC;

एकाधिक उत्पादकों और उपभोक्ताओं को एक ही बफर साझा करना

यह उदाहरण कई उत्पादकों और उपभोक्ताओं को एक ही बफर साझा करने को दर्शाता है। Ada में संरक्षित प्रविष्टियाँ प्रतीक्षा कार्यों को संभालने के लिए एक कतार लागू करती हैं। डिफ़ॉल्ट कतारबद्ध नीति फर्स्ट इन फर्स्ट आउट है।

------------------------------------------------------------------
-- Multiple producers and consumers sharing the same buffer --
------------------------------------------------------------------
with Ada.Text_IO; use Ada.Text_Io;

procedure N_Prod_Con is
   protected Buffer is
      Entry Write(Item : in Integer);
      Entry Read(Item : Out Integer);
   private
      Value  : Integer := Integer'Last;
      Is_New : Boolean := False;
   end Buffer;
   protected body Buffer is
      Entry Write(Item : in Integer) when not Is_New is
      begin
         Value := Item;
         Is_New := True;
      end Write;
      Entry Read(Item : out Integer) when Is_New is
      begin
         Item := Value;
         Is_New := False;
      end Read;
   end Buffer;

   task type Producers(Id : Positive) is
      Entry Stop;
   end Producers;
   task body Producers is
      Num : Positive := 1;
   begin
      loop
         select
            accept Stop;
            exit;
         or
            delay 0.0001;
         end select;
         Put_Line("Producer" & Integer'Image(Id) & " writing" & Integer'Image(Num));
         Buffer.Write(Num);
         Num := Num + 1;
      end loop;
   end Producers;

   task type Consumers(Id : Positive) is
      Entry Stop;
   end Consumers;

   task body Consumers is
      Num : Integer;
   begin
      loop
         select
            accept stop;
            exit;
         or
            delay 0.0001;
         end select;
         Buffer.Read(Num);
         Put_Line("Consumer" & Integer'Image(ID) & " read" & Integer'Image(Num));
      end loop;
   end Consumers;
   P1 : Producers(1);
   P2 : Producers(2);
   P3 : Producers(3);
   C1 : Consumers(1);
   C2 : Consumers(2);
   C3 : Consumers(3);
begin
   delay 0.2;
   P1.Stop;
   P2.Stop;
   P3.Stop;
   C1.Stop;
   C2.Stop;
   C3.Stop;
end N_Prod_Con;