klasse ara::core::Executor

De klasse ara::core::Executor biedt een interface voor de asynchrone uitvoering van aanroepbare objecten in een gegarandeerde thread-safe context. Taken worden ofwel resultaatgericht via execute [SWS_CORE_00024] met teruggave van een ara::core::Future voor waarden of foutcodes gestart, ofwel statusonafhankelijk via oneway_execute [SWS_CORE_00025] in fire-and-forget-modus overgedragen. Als centrale randvoorwaarde moet worden opgemerkt dat execute zelf niet thread-safe is en parallelle aanroepen op dezelfde instantie extern moeten worden gesynchroniseerd, terwijl de uitvoering van de callable op de achtergrond thread-safe plaatsvindt.

meer ›

Context

De klasse ara::core::Executor biedt een interface voor een uitvoeringscontext die aanroepbare eenheden (callables) asynchroon in een gegarandeerde, thread-safe omgeving uitvoert. Ze dient als abstractielaag tussen de aanroepende thread en de asynchrone achtergrondverwerking. Voor de overdracht van opdrachten zijn twee mechanismen beschikbaar: De methode execute [SWS_CORE_00024] draagt een taak resultaatgericht over en retourneert een ara::core::Future-object, waarmee de latere retourwaarde of een foutcode kan worden gesynchroniseerd en opgevraagd. Voor loutere notificaties of statusonafhankelijke achtergrondoperaties biedt de klasse de methode oneway_execute [SWS_CORE_00025], die een fire-and-forget-semantiek volgt en geen asynchrone context aan de aanroeper teruglevert. Vermoedelijk kapselt de concrete implementatie op de achtergrond een threadbeheer of taakwachtrij in om de gelijktijdige verwerking te coördineren. Vraag Q-068fe33f2900d6cf (open)

Levenscyclus

De instantiëring en levensduur van een ara::core::Executor zijn onderworpen aan gedifferentieerde regels met betrekking tot exception safety en thread safety:

• Kopiëren: De copy-constructor [SWS_CORE_00009] en de copy-assignment-operator [SWS_CORE_00017] zijn als thread-safe gespecificeerd, maar niet als exception-safe (not exception safe) geclassificeerd. Een kopieerbewerking kan daarom mislukken als benodigde resources niet kunnen worden gealloceerd.
• Verplaatsen: De move-constructor [SWS_CORE_00015] en de move-assignment [SWS_CORE_00018] zijn gedeclareerd als noexcept en daarmee exception-safe. Verplaatsingsbewerkingen zijn echter niet thread-safe (not thread-safe), waardoor gelijktijdige toegangen tijdens het verplaatsen door de aanroeper moeten worden gesynchroniseerd.
• Vernietiging: De destructor [SWS_CORE_00019] is uitgevoerd als noexcept en thread-safe, waardoor de levenscyclus van een instantie veilig kan worden beëindigd.

Wat betreft gelijktijdigheid tijdens bedrijf is een fundamentele scheiding zichtbaar: Terwijl oneway_execute [SWS_CORE_00025] thread-safe is, is execute [SWS_CORE_00024] geclassificeerd als niet thread-safe. Het ontbreken van thread safety bij execute is vermoedelijk toe te schrijven aan het intern aanmaken en beheren van het onderliggende toestandsobject voor de resulterende future, waardoor gelijktijdige aanroepen van execute op dezelfde instantie extern moeten worden gesynchroniseerd. Vraag Q-4425e6b07758230e (open)

Gebruikspad

Het gebruik van ara::core::Executor valt uiteen in twee hoofdtrajecten, afhankelijk van de vraag of een retourwaarde vereist is:

1. Resultaatgericht pad (execute): De aanroeper draagt een aanroepbaar object f en optionele argumenten p... over aan execute [SWS_CORE_00024]. De methode levert onmiddellijk een ara::core::Future terug, waarvan het resultaattype is gebaseerd op het afgeleide retourtype van de aanroep. De callable wordt asynchroon in de gegarandeerde context uitgevoerd. Zodra de verwerking is voltooid, kan de aanroeper de resultaatwaarde of een potentiële foutcode uit de future extraheren.
2. Eenrichtingspad (oneway_execute): Heeft de aanroeper respons noch synchronisatie nodig, dan wordt oneway_execute [SWS_CORE_00025] aangeroepen. De callable wordt eveneens asynchroon uitgevoerd, maar er bestaat geen retourwaarde (void).

Sequentiediagram: Asynchrone taakafhandeling via execute en opvragen van het resultaat via future. Bronnen: [SWS_CORE_00024]

Foutscenario's

De aanroepmethoden execute [SWS_CORE_00024] en oneway_execute [SWS_CORE_00025] werpen geen C++-uitzonderingen op; beide zijn expliciet gespecificeerd als noexcept. Evenzo definieert de specificatie voor execute geen gestandaardiseerde foutcodes voor de overdrachtsaanroep zelf [SWS_CORE_00024].

Treedt er echter tijdens de asynchrone verwerking van de callable een fout op, dan wordt deze gepropageerd via het door execute geretourneerde ara::core::Future: in geval van een fout kapselt de future een foutcode in, terwijl bij succes het type ara::core::Result::value_type met het functieresultaat beschikbaar wordt gesteld [SWS_CORE_00024]. Bij oneway_execute [SWS_CORE_00025] bestaat er door het ontwerp geen mogelijkheid tot foutteruggave aan de aanroeper; fouten blijven in de asynchrone context.