Provides an interface for a executing context, which asynchronously invokes Callable ([4] [func.wrap.func]) objects in a guaranteed thread-safe context. The execute(...) method in [SWS_CORE_00024] returns a ara::core::Future object to the caller for further result/error extraction or management of the asynchronous-context; the execute_oneway(...) method in [SWS_CORE_00025] imply fire-and-forget semantics and thus no asynchronous-context (ara::core::Future) is returned.
Literaturverzeichnis SWS Core: [4] ISO/IEC 14882:2014, Information technology – Programming languages – C++ – www.iso.org
Permet l'exécution asynchrone et sûre pour les threads d'objets appelables, avec retour optionnel via des futures.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 690890643de1ProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Permet l'exécution asynchrone et sûre pour les threads d'objets appelables, avec retour optionnel via des futures.
La classe ara::core::Executor fournit une interface pour l'exécution asynchrone d'objets appelables dans un contexte garanti sûr pour les threads. Les tâches sont initiées soit orientées résultat via execute[SWS_CORE_00024] avec retour d'un ara::core::Future pour les valeurs ou codes d'erreur, soit indépendamment de leur statut via oneway_execute[SWS_CORE_00025] en mode « fire-and-forget ». En tant que contrainte centrale, il convient de noter que execute n'est pas elle-même sûre pour les threads et que les appels parallèles sur une même instance doivent être synchronisés de manière externe, tandis que l'exécution du callable en arrière-plan s'effectue de manière sûre pour les threads.
Contexte
La classe ara::core::Executor met à disposition une interface pour un contexte d'exécution qui exécute des unités appelables (callables) de manière asynchrone dans un environnement garanti sûr pour les threads. Elle sert de couche d'abstraction entre le thread appelant et le traitement asynchrone en arrière-plan. Deux mécanismes sont disponibles pour la transmission des ordres : la méthode execute[SWS_CORE_00024] transmet une tâche de manière orientée résultat et renvoie un objet ara::core::Future par l'intermédiaire duquel la valeur de retour ultérieure ou un code d'erreur peut être synchronisé et interrogé. Pour les simples notifications ou les opérations d'arrière-plan indépendantes de l'état, la classe met à disposition la méthode oneway_execute[SWS_CORE_00025], qui suit une sémantique « fire-and-forget » et ne renvoie aucun contexte asynchrone à l'appelant. Vraisemblablement, l'implémentation concrète encapsule en arrière-plan une gestion de threads ou une file d'attente de tâches afin de coordonner l'exécution concurrente. Question Q-068fe33f2900d6cf (ouverte)
Cycle de vie
L'instanciation et la durée de vie d'un ara::core::Executor sont soumises à des règles différenciées quant à la sécurité vis-à-vis des exceptions et des threads :
Copie : le constructeur de copie [SWS_CORE_00009] ainsi que l'opérateur d'assignation par copie [SWS_CORE_00017] sont spécifiés comme sûrs pour les threads, mais ne sont pas classés comme sûrs vis-à-vis des exceptions (not exception safe). Une opération de copie peut donc échouer si les ressources nécessaires ne peuvent pas être allouées.
Déplacement : le constructeur de déplacement [SWS_CORE_00015] et l'assignation par déplacement [SWS_CORE_00018] sont déclarés comme noexcept et sont donc sûrs vis-à-vis des exceptions. Toutefois, les opérations de déplacement ne sont pas sûres pour les threads (not thread-safe), raison pour laquelle les accès simultanés pendant le déplacement doivent être synchronisés par l'appelant.
Destruction : le destructeur [SWS_CORE_00019] est noexcept et réalisé de manière sûre pour les threads, ce qui permet de mettre fin en toute sécurité au cycle de vie d'une instance.
En ce qui concerne la concurrence pendant le fonctionnement, une séparation fondamentale apparaît : alors que oneway_execute[SWS_CORE_00025] est sûr pour les threads, execute[SWS_CORE_00024] est classé comme non sûr pour les threads. L'absence de sécurité des threads pour execute provient sans doute de la création et de la gestion internes de l'objet d'état sous-jacent pour le future résultant, raison pour laquelle les appels simultanés de execute sur la même instance doivent être synchronisés de manière externe. Question Q-4425e6b07758230e (ouverte)
Parcours d'utilisation
L'utilisation de ara::core::Executor se divise en deux voies principales, selon qu'une valeur de retour est requise ou non :
Voie orientée résultat (execute) : l'appelant transmet un objet appelable f ainsi que des arguments optionnels p... à execute[SWS_CORE_00024]. La méthode renvoie immédiatement un ara::core::Future dont le type de résultat est basé sur le type de retour déduit de l'appel. Le callable est exécuté de manière asynchrone dans le contexte garanti. Dès que le traitement est terminé, l'appelant peut extraire la valeur de résultat ou un éventuel code d'erreur depuis le future.
Voie à sens unique (oneway_execute) : si l'appelant n'a besoin ni de retour ni de synchronisation, oneway_execute[SWS_CORE_00025] est appelée. Le callable est également exécuté de manière asynchrone, mais aucune valeur de retour n'existe (void).
Diagramme de séquence : traitement asynchrone de tâches via execute et interrogation du résultat via Future. Sources : [SWS_CORE_00024]
Scénarios d'erreur
Les méthodes d'appel execute[SWS_CORE_00024] et oneway_execute[SWS_CORE_00025] ne lèvent aucune exception C++ ; toutes deux sont explicitement spécifiées comme noexcept. De même, la spécification ne définit pour execute aucun code d'erreur standardisé pour l'appel de transmission lui-même [SWS_CORE_00024].
Toutefois, si une erreur survient pendant l'exécution asynchrone du callable, celle-ci est propagée via le ara::core::Future renvoyé par execute : en cas d'erreur, le future encapsule un code d'erreur, tandis qu'en cas de succès, le type ara::core::Result::value_type contenant le résultat de la fonction est mis à disposition [SWS_CORE_00024]. Avec oneway_execute[SWS_CORE_00025], il n'existe par conception aucune possibilité de retour d'erreur à l'appelant ; les erreurs demeurent dans le contexte asynchrone.
Ce guide a été préparé par une IA et s'appuie exclusivement sur la spécification d'AUTOSAR Adaptive R25-11.
Asynchronously invoke F with the provided arguments P....
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 9d31d266cefdProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction execute de la classe ara::core::Executor sert à l'exécution asynchrone d'un objet fonction transmis f conjointement avec les arguments p... ([SWS_CORE_00024]). Comme valeur de retour, elle fournit un ara::core::Future qui, en cas de succès, encapsule le résultat de l'appel ou, en cas d'erreur, fournit un code d'erreur correspondant ([SWS_CORE_00024]). La fonction elle-même est déclarée avec le spécificateur noexcept.
Aucun code d'erreur standardisé n'est spécifié pour l'appel de fonction ([SWS_CORE_00024]). En ce qui concerne la concurrence, execute est certes classé comme exception safe, mais est explicitement considéré comme not thread-safe ([SWS_CORE_00024]). Les accès parallèles à la même instance de ara::core::Executor devraient donc devoir être synchronisés au niveau de l'utilisateur. Question Q-6b839826a7d9742f (ouverte)
L'interaction avec les flux de contrôle asynchrones apparaît notamment lors des chaînages via then ([SWS_CORE_00337], [SWS_CORE_06237]). Un contexte d'exécuteur y est transmis, contexte dans lequel les fonctions de continuation subséquentes sont exécutées avec le ara::core::Result obtenu.
Ce texte a été généré automatiquement. Toutes les indications techniques sont basées sur la spécification AUTOSAR Adaptive R25-11.
ara::core::Future<std::invoke_result_t<std::decay_t< F >, std::decay_t< P >... > >
• If successful: an ara::core::Future containing a ara:: core::Result::value_type containing the result of the callable F • If unsuccessful: an ara::core::Future containing an Error Code
Fehler
Fehlercode
Beschreibung
This function does not specify any standardized errors.
Request a governed re-review of this record. The record is not changed immediately.
Asynchronously invoke F with the provided arguments P....
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 1e96ad32e48dProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation et sémantique
La fonction template oneway_execute de la classe ara::core::Executor sert à exécuter de manière asynchrone une unité appelable f (Callable) avec les arguments transmis p...[SWS_CORE_00025]. Comme la fonction ne renvoie aucune valeur de retour (type de retour void) et que l'exécution est asynchrone, l'appel retourne immédiatement à l'appelant sans attendre la fin ou un résultat de l'exécution [SWS_CORE_00025].
Gestion des erreurs et sécurité vis-à-vis des exceptions
La fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CORE_00025]. D'éventuelles erreurs ou exceptions au sein du callable transmis doivent donc vraisemblablement être interceptées et traitées en interne dans le callable lui-même, car aucun retour d'erreur ou exception ne peut être transmis au contexte appelant. Question Q-c8d31cfa9c2e3ab9 (ouverte)
Concurrence et restrictions
Conformément à la spécification, oneway_execute est classée comme sûre pour les threads (thread-safe) [SWS_CORE_00025]. La fonction peut donc être appelée de manière concurrente depuis différents threads sur la même instance de ara::core::Executor. L'inclusion s'effectue via le fichier d'en-tête #include "ara/core/executor.h"[SWS_CORE_00025].
Cette note d'utilisation a été générée de manière automatisée sur la base d'AUTOSAR R25-11.
gemini-3.8-flash-low· 2026-10-13 · Original allemand