Udostępnij za pośrednictwem

Biblioteka agentów asynchroniczne

  • Artykuł

Asynchroniczne biblioteki agentów (lub po prostu Biblioteki agenci) udostępnia model programowania, który pozwala na zwiększenie niezawodności tworzenia aplikacji z obsługą współbieżności.Biblioteka agentów jest biblioteki szablonów języka C++, promocyjna aktor na model programowania i wiadomości w trakcie przekazywania dla coarse-grained przepływ danych oraz przetwarzanie potokowe zadań.Biblioteka agentów opiera się na składniki zarządzania planowania i zasobów Runtime współbieżności.

Model programowania

Biblioteka agentów dostarcza rozwiązania alternatywne do stanu udostępnionego umożliwia łączenie składników izolowane za pośrednictwem modelu komunikacji asynchronicznej, opartą na przepływ danych zamiast kontroli przepływu.Przepływ danych odnosi się do programowania modelu, w których są wykonane obliczenia, kiedy wszystkie wymagane dane są dostępne. Sterowanie przepływem odnosi się do modelu programowania, gdy następuje w kolejności wstępnie obliczenia.

Model programowania przepływ danych jest związane z koncepcji przekazywanie komunikatów, gdzie niezależnych składników programu komunikują się ze sobą przez wysłanie wiadomości.

Biblioteka agentów składa się z trzech części: asynchronicznego agenci, bloków asynchroniczny komunikat, i funkcji przekazywania wiadomości.Agenci utrzymywania stanu i komunikować się ze sobą i składników zewnętrznych za pomocą funkcji przekazywania wiadomości i bloków komunikatów.Funkcje służące do przekazywania wiadomości włączyć agentów do wysyłania i odbierania wiadomości do i ze składników zewnętrznych.Komunikat asynchroniczny bloki przechowywania wiadomości i włączyć agentów do komunikowania się w sposób zsynchronizowane.

Ilustracji zawiera agentów jak dwa bloki komunikatów wykorzystania i funkcje służące do 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 funkcji przeczytać wiadomość.agent2używa tej samej metody, aby wysłać wiadomość do agent1.Strzałki przerywane przedstawiają przepływ danych między agentów.Stałe strzałek połączyć agentów bloki komunikatów, które zapisu lub odczytu.

Składniki biblioteki agentów

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

Model programowania agent ma kilka zalet, za pośrednictwem 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 wyizolować dostęp do zasobów udostępnionych i tym samym poprawić skalowalność.Zaletą przekazywania wiadomości jest, że wiąże synchronizacji danych zamiast sprzedaż wiązana go do obiektu zewnętrznego synchronizacji.Upraszcza przesyłania danych między składnikami i można wyeliminować błędy programowania w aplikacji.

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

Jeśli masz wiele operacji, które muszą komunikować się ze sobą asynchronicznie za pomocą biblioteki agentów.Bloki komunikatów i funkcje służące do przekazywania wiadomości pozwalają pisać aplikacje równolegle bez konieczności synchronizacji mechanizmów, takich jak blokad.Pozwala to skupić logiki aplikacji.

Model programowania agenta jest często używany do tworzenia danych rurociągów lub sieci.Rurociąg danych jest szereg elementów, z których każda wykonuje określone zadanie, który przyczynia się do ogólnego celu.Każdy składnik w rurociągu przepływ danych wykonuje pracę po odebraniu wiadomości z innego składnika.Wynik tej pracy jest przekazywane do innych składników w potoku lub sieci.Składniki można użyć więcej funkcji szczegółowymi współbieżności z innych bibliotek, na przykład, Biblioteka desenie równoległe (PPL).

Przykład

Poniższy przykład 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:

agent1: sending request...
agent2: received 'request'.
agent2: sending response...
agent1: received '42'.

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

Tematy pokrewne