Compartilhar via

Biblioteca de agentes assíncrono

  • Artigo

A biblioteca assíncrona de agentes (ou apenas a biblioteca de agentes) fornecem um modelo de programação que permite que você aumentar a robustez de desenvolvimento de aplicativos simultaneidade- ativado.A biblioteca de agentes é a biblioteca do modelo de c++ que promove uma programação ator- base no modelo e a mensagem em processo que passa para o fluxo de dados de alta granularidade e que canaliza tarefas.A biblioteca de agentes compila os componentes de programação e de gerenciamento de recursos de tempo de execução de simultaneidade.

Modelo de programação

A biblioteca de agentes forneça alternativas ao estado compartilhado deixando o conectar-se componentes isolados por um modelo de comunicação assíncrona que é baseado no fluxo de dados em vez de fluxo de controle.O fluxo de dados se refere a um modelo de programação que computações sejam feitas quando todos os dados necessários estão disponíveis; o fluxo de controle se refere a um modelo de programação que computações sejam feitas em uma ordem predeterminado.

O modelo de programação do fluxo de dados está relacionado ao conceito de mensagem que passa, onde componentes independentes de um programa se comunicam com um outro enviar mensagens.

A biblioteca de agentes é composta de três componentes: agentes assíncronas, blocos assíncronas de mensagem, e mensagem- passar funções.Agentes mantêm estado, e os blocos de mensagem uso das funções e mensagem- passar para se comunicar com um outro e com componentes externos.Mensagem- passando as funções permitem agentes para enviar e receber mensagens a e componentes externos.Blocos assíncronas de mensagem contêm mensagens e permitem agentes de uma maneira para se comunicar sincronizado.

A ilustração a seguir mostra como agentes dois blocos de mensagem de uso e funções mensagem- passar para se comunicar.Nesta ilustração, envia de agent1 uma mensagem a agent2 usando a função de concurrency::send e um concurrency::unbounded_buffer objeto.agent2 usa a função para ler de concurrency::receive a mensagem.agent2 usa o mesmo método para enviar uma mensagem a agent1.As setas tracejadas representam o fluxo de dados entre agentes.As setas contínuas seus agentes aos blocos da mensagem que gravam ou ler de.

Os componentes da biblioteca de agentes

Um exemplo de código que implementa esta ilustração é mostrado neste tópico posteriormente.

O modelo de programação do agente tem várias vantagens sobre outros mecanismos de simultaneidade e de sincronização, por exemplo, eventos.Uma vantagem é que usando a mensagem que passa para transmitir alterações de estado entre objetos, você pode isolar acesso aos recursos compartilhados, e melhorar a escalabilidade dessa maneira.Uma vantagem para passar de mensagem é cadeia de caracteres que a sincronização a dados em vez da para um objeto externo de sincronização.Isso simplifica a transmissão de dados entre componentes e pode eliminar erros de programação em seus aplicativos.

Quando usar a biblioteca de agentes

Use a biblioteca de agentes quando você tiver várias operações que devem se comunicar com um outro de forma assíncrona.Blocos de mensagem e funções mensagem- passar permitem que você escrever aplicativos sem exigir mecanismos paralelos de sincronização como bloqueios.Isso permite que você focalizar a lógica do aplicativo.

O modelo de programação do é frequentemente usado para criar pipelines de dados ou redes.Um pipeline de dados é uma série de componentes, cada um de eles executa uma tarefa específica que contribua a um objetivo maior.Cada componente em um canal do fluxo de dados executa o trabalho quando receber uma mensagem de outro componente.O resultado desse trabalho é passado para outros componentes no canal ou na rede.Componentes podem usar mais funcionalidade mais aguçado de simultaneidade de outras bibliotecas, por exemplo, A modelos paralela a biblioteca (PPL).

Exemplo

O exemplo a seguir implementa a ilustração mostrada anteriormente neste tópico.

// 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);
}

Esse exemplo produz a seguinte saída.

Os tópicos a seguir descrevem a funcionalidade usada neste exemplo.

Tópicos relacionados