Udostępnij za pośrednictwem

Biblioteka agentów asynchronicznych

  • Artykuł

Asynchroniczne biblioteki agentów (lub po prostu Biblioteki agentów) zapewnia model programowania, który pozwala zwiększyć sprawność działania aplikacji obsługującej współbieżność rozwoju.Biblioteka agentów jest Biblioteka szablonów języka C++, która promuje model programowania opartego na aktor i wiadomości w trakcie przekazywania dla gruboziarnistych przepływ danych oraz przetwarzanie potokowe zadań.Biblioteki agentów opiera się na składniki zarządzania planowanie i środowiska wykonawczego współbieżności.

Model programowania

Biblioteka agentów zapewnia rozwiązania alternatywne w stosunku do stanu udostępnionego umożliwiając łączą składniki na białym tle poprzez modelu komunikacji asynchronicznej, który opiera się na przepływ danych zamiast kontroli przepływu.Przepływ danych odnosi się do programowania modelu, gdzie obliczenia są wtedy, gdy wszystkie wymagane dane są dostępne; Przepływ sterowania odwołuje się do modelu programowania, gdzie obliczeń są wykonane w określonej kolejności.

Model programowania przepływu danych jest powiązany z pojęciem przekazywania wiadomości, gdzie niezależne składniki programu komunikują się ze sobą, przez wysyłanie wiadomości.

Biblioteki agentów składa się z trzech części: asynchronicznego agenci, bloków komunikatów asynchroniczne, i funkcji przekazywania wiadomości.Agenci zarządzania stanem i użyć funkcji przekazywania wiadomości i bloków komunikatów, aby komunikować się ze sobą i składników zewnętrznych.Funkcje przekazywania wiadomości umożliwiają agentów do wysyłania i odbierania wiadomości do i ze składników zewnętrznych.Bloki o wiadomościach asynchronicznych przechowywania wiadomości i włączyć agentów do komunikowania się w sposób zsynchronizowane.

Na poniższej ilustracji przedstawiono sposób dwóch agentów użycie bloków komunikatów i funkcji przekazywania wiadomości do komunikowania się.Na tej ilustracji agent1 wysyła wiadomość do agent2 za pomocą concurrency::send funkcji i concurrency::unbounded_buffer obiektu.agent2używa concurrency::receive funkcja przeczytać wiadomość.agent2używa tej samej metody, aby wysłać wiadomość do agent1.Strzałki przerywane przedstawiają przepływ danych między agentami.Stałe strzałek połączyć bloków komunikatów, które zapisu lub odczytu z agentów.

Składniki biblioteki agentów

Przykładowy kod, który implementuje tej ilustracji przedstawiono w dalszej części tego tematu.

Model programowania agent ma wiele zalet w porównaniu do innych mechanizmów współbieżności i synchronizacji, na przykład zdarzenia.Jedną z zalet jest, że za pomocą przekazywania wiadomości do przesyłania zmian stanu między obiektami, można izolować dostęp do zasobów udostępnionych i tym samym poprawić skalowalność.Zaletą przekazywanie komunikatów jest wiąże synchronizacji do danych zamiast wiązanie go do obiektu zewnętrznego synchronizacji.Upraszcza transmisji danych między składnikami i wyeliminować błędy programowania w aplikacji.

Kiedy należy używać biblioteki agentów

Kiedy masz wiele operacji, które muszą się komunikować ze sobą asynchronicznie za pomocą biblioteki agentów.Bloków komunikatów i funkcji przekazywania wiadomości umożliwiają tworzenie aplikacji równoległych bez konieczności synchronizacji mechanizmów, takich jak blokad.Pozwala to skupić się na logikę aplikacji.

Model programowania agent jest często używany do tworzenia danych rurociągów lub sieci.Rurociąg danych jest to szereg składników, z których każda wykonuje określone zadanie, który przyczynia się do ogólnego celu.Każdy składnik potoku przepływ danych wykonuje pracę, gdy odbiera wiadomość z innego składnika.Wynik tej pracy jest przekazywana do innych składników w gazociąg lub sieć.Składniki można użyć większą funkcjonalność drobnoziarnistych współbieżność z innych bibliotek, na przykład, Biblioteka równoległych wzorców (PLL).

Przykład

W poniższym przykładzie implementuje ilustracji pokazano wcześniej w tym temacie.

// basic-agents.cpp 
// compile with: /EHsc
#include <agents.h>
#include <string>
#include <iostream>
#include <sstream>

using namespace concurrency;
using namespace std;

// This agent writes a string to its target and reads an integer 
// from its source. 
class agent1 : public agent 
{
public:
   explicit agent1(ISource<int>& source, ITarget<wstring>& target)
      : _source(source)
      , _target(target)
   {
   }

protected:
   void run()
   {
      // Send the request.
      wstringstream ss;
      ss << L"agent1: sending request..." << endl;
      wcout << ss.str();

      send(_target, wstring(L"request"));

      // Read the response. 
      int response = receive(_source);

      ss = wstringstream();
      ss << L"agent1: received '" << response << L"'." << endl;
      wcout << ss.str();

      // Move the agent to the finished state.
      done();
   }

private:   
   ISource<int>& _source;
   ITarget<wstring>& _target;
};

// This agent reads a string to its source and then writes an integer 
// to its target. 
class agent2 : public agent 
{
public:
   explicit agent2(ISource<wstring>& source, ITarget<int>& target)
      : _source(source)
      , _target(target)
   {
   }

protected:
   void run()
   {
      // Read the request.
      wstring request = receive(_source);

      wstringstream ss;
      ss << L"agent2: received '" << request << L"'." << endl;
      wcout << ss.str();

      // Send the response.
      ss = wstringstream();
      ss << L"agent2: sending response..." << endl;
      wcout << ss.str();

      send(_target, 42);

      // Move the agent to the finished state.
      done();
   }

private:   
   ISource<wstring>& _source;
   ITarget<int>& _target;
};

int wmain()
{
   // Step 1: Create two message buffers to serve as communication channels 
   // between the agents. 

   // The first agent writes messages to this buffer; the second 
   // agents reads messages from this buffer.
   unbounded_buffer<wstring> buffer1;

   // The first agent reads messages from this buffer; the second 
   // agents writes messages to this buffer.
   overwrite_buffer<int> buffer2;

   // Step 2: Create the agents.
   agent1 first_agent(buffer2, buffer1);
   agent2 second_agent(buffer1, buffer2);

   // Step 3: Start the agents. The runtime calls the run method on 
   // each agent.
   first_agent.start();
   second_agent.start();

   // Step 4: Wait for both agents to finish.
   agent::wait(&first_agent);
   agent::wait(&second_agent);
}

Ten przykład generuje następujące wyniki:

W następujących tematach opisano funkcje używane w tym przykładzie.

Tematy pokrewne