Sdílet prostřednictvím

Asynchronní agenti knihovny

  • Článek

Asynchronní agenti knihovny (nebo pouze Agenti knihovny) poskytuje programovací model, který umožňuje zvýšit odolnost vývoj aplikací povoleno souběžnosti.Knihovna agentů je C++ knihovna šablon, který podporuje založené na herce programovací model a zprávy v procesu předávání pro coarse-grained tok dat a použití kanálů úkoly.Knihovna agenti staví na plánování a prostředků součásti řízení souběžnosti Runtime.

Model programování

Agenti knihovna poskytuje sdílený stav alternativy dovolte připojit prostřednictvím asynchronní komunikaci modelu, založené na datový tok namísto toku řízení izolovaných součástí.Datový tok odkazuje programovací model, kde jsou prováděny výpočty při všechny požadované údaje k dispozici; řízení toku odkazuje na programovací model, kde jsou prováděny výpočty v předem pořadí.

Programovací model tok dat se vztahuje k pojmu předávání zpráv, kde nezávislé součásti programu komunikují pomocí odesílání zpráv.

Agenti knihovna se skládá ze tří komponent: agenti asynchronní, bloky asynchronní zprávu, a funkce předávání zpráv.Agenti udržení stavu a komunikovat mezi sebou a s externí součásti pomocí funkce předávání zpráv a bloků zprávy.Povolení funkce předávání zpráv odesílat a přijímat zprávy z externích součástí a agentů.Asynchronní zprávu bloky podržte zprávy a povolit agenti synchronizované způsobem komunikovat.

Následující obrázek ukazuje jak dva agenti funkce předávání zpráv komunikovat a bloků zprávy použít.Na tomto obrázku agent1 odešle zprávu agent2 pomocí concurrency::send funkci a concurrency::unbounded_buffer objektu.agent2používá concurrency::receive funkci číst zprávy.agent2používá stejné metody k odeslání zprávy agent1.Přerušované šipky představují tok dat mezi agenty.Plné šipky připojení agentů bloků zprávy, které číst nebo zapisovat.

Součástí knihovny agentů

Příklad kódu, který implementuje na tomto obrázku je uvedeno dále v tomto tématu.

Agent programovací model má několik výhod nad jiné souběžnost a synchronizace mechanismy, například události.Výhodou je, že pomocí předávání zprávy předávat změny stavu mezi objekty můžete izolovat přístup ke sdíleným prostředkům a zdokonalit škálovatelnost.Předávání zpráv výhodou je, že jej spojuje synchronizace dat provázání objektu externí synchronizace.To zjednodušuje přenos dat mezi součástmi a vyloučit chyby programování aplikací.

Použití knihovny agenti

Použití knihovny agenti, pokud máte více operací, které musíte komunikují asynchronně.Funkce předávání zpráv a bloků zprávy umožňují psát paralelní aplikace bez nutnosti mechanismů synchronizace například zámky.Tento umožňuje zaměřit se na aplikační logiku.

Programovací model agenta se často používá k vytvoření dat potrubí nebo sítí.Data potrubí je řady komponent, které provádí konkrétní úkol, který přispívá k větší cíl.Každé součásti potrubí tok dat provádí práce při obdržení zprávy od jiných komponent.Výsledek této práce je předán další součásti v potrubí nebo síť.Komponenty můžete použít další funkce uzamykání souběžnosti z jiných knihoven, například, Paralelní knihovnu vzorků (PPL).

Příklad

Následující příklad implementuje ilustrace uvedené dříve v tomto tématu.

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

Tento příklad vytvoří následující výstup:

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

Následující témata popisují funkce použité v tomto příkladu.

Příbuzná témata