classe ara::core::Executor

A classe ara::core::Executor fornece uma interface para a execução assíncrona de objetos chamáveis em um contexto com garantia de segurança de threads (thread-safe). As tarefas são iniciadas de forma orientada a resultados via execute [SWS_CORE_00024] com o retorno de um ara::core::Future para valores ou códigos de erro, ou transferidas independentemente de status por oneway_execute [SWS_CORE_00025] no modo fire-and-forget. Como condição de contorno central, deve-se observar que execute em si não é thread-safe e chamadas paralelas na mesma instância precisam ser sincronizadas externamente, enquanto a execução do callable em segundo plano ocorre de forma thread-safe.

mais ›

Contexto

A classe ara::core::Executor fornece uma interface para um contexto de execução que executa unidades chamáveis (callables) de forma assíncrona em um ambiente garantidamente thread-safe. Ela serve como camada de abstração entre a thread chamadora e o processamento assíncrono em segundo plano. Dois mecanismos estão disponíveis para a transferência de tarefas: o método execute [SWS_CORE_00024] transfere uma tarefa de modo orientado a resultados e retorna um objeto ara::core::Future, através do qual o valor de retorno posterior ou um código de erro pode ser sincronizado e consultado. Para meras notificações ou operações de segundo plano independentes de status, a classe disponibiliza o método oneway_execute [SWS_CORE_00025], que segue uma semântica fire-and-forget e não retorna nenhum contexto assíncrono ao chamador. Supõe-se que a implementação concreta encapsule em segundo plano um gerenciamento de threads ou uma fila de tarefas para coordenar o processamento concorrente. Pergunta Q-068fe33f2900d6cf (aberta)

Ciclo de vida

A instanciação e o ciclo de vida de um ara::core::Executor estão sujeitos a regras diferenciadas quanto à segurança de exceções e de threads:

• Cópia: o construtor de cópia [SWS_CORE_00009] e o operador de atribuição por cópia [SWS_CORE_00017] são especificados como thread-safe, mas não são classificados como seguros para exceções (not exception safe). Um processo de cópia pode, portanto, falhar se os recursos necessários não puderem ser alocados.
• Movimentação: o construtor de movimentação [SWS_CORE_00015] e a atribuição por movimentação [SWS_CORE_00018] são declarados como noexcept e, portanto, seguros para exceções. No entanto, as operações de movimentação não são thread-safe (not thread-safe), razão pela qual acessos simultâneos durante a movimentação devem ser sincronizados pelo chamador.
• Destruição: o destrutor [SWS_CORE_00019] é noexcept e implementado como thread-safe, permitindo que o ciclo de vida de uma instância seja encerrado com segurança.

Em relação à concorrência durante a operação, nota-se uma divisão fundamental: enquanto oneway_execute [SWS_CORE_00025] é thread-safe, execute [SWS_CORE_00024] é classificado como não thread-safe. A ausência de segurança de threads em execute decorre, provavelmente, da criação e do gerenciamento internos do objeto de estado subjacente para o future resultante, razão pela qual chamadas simultâneas de execute na mesma instância devem ser sincronizadas externamente. Pergunta Q-4425e6b07758230e (aberta)

Caminho de utilização

O uso de ara::core::Executor divide-se em dois caminhos principais, dependendo da necessidade de um valor de retorno:

1. Caminho orientado a resultados (execute): o chamador transfere um objeto chamável f bem como argumentos opcionais p... para execute [SWS_CORE_00024]. O método retorna imediatamente um ara::core::Future, cujo tipo de resultado se baseia no tipo de retorno deduzido da chamada. O callable é executado de forma assíncrona no contexto garantido. Assim que o processamento for concluído, o chamador pode extrair o valor do resultado ou um potencial código de erro a partir do future.
2. Caminho unidirecional (oneway_execute): se o chamador não necessitar de confirmação nem de sincronização, oneway_execute [SWS_CORE_00025] é chamado. O callable também é executado de forma assíncrona, mas não existe um valor de retorno (void).

Diagrama de sequência: processamento assíncrono de tarefas via execute e consulta de resultados via future. Fontes: [SWS_CORE_00024]

Cenários de erro

Os métodos de invocação execute [SWS_CORE_00024] e oneway_execute [SWS_CORE_00025] não lançam exceções de C++; ambos são especificados explicitamente como noexcept. Da mesma forma, a especificação para execute não define códigos de erro padronizados para a chamada de transferência em si [SWS_CORE_00024].

No entanto, se ocorrer um erro durante o processamento assíncrono do callable, ele será propagado através do ara::core::Future retornado por execute: em caso de erro, o future encapsula um código de erro, enquanto em caso de sucesso o tipo ara::core::Result::value_type é disponibilizado com o resultado da função [SWS_CORE_00024]. Em oneway_execute [SWS_CORE_00025], por projeto, não há possibilidade de retorno de erro ao chamador; os erros permanecem no contexto assíncrono.