Funções <future>
async
future_category
make_error_code
make_error_condition
swap
|
async
Representa um provedor assíncrono.
template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
async(Fn&& fn, ArgTypes&&... args);
template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
async(launch policy, Fn&& fn, ArgTypes&&... args);
Parâmetros
política
Um valor launch
.
Comentários
Definições das abreviações:
Abreviação | Descrição |
---|---|
dfn |
O resultado da chamada para decay_copy(forward<Fn>(fn)) . |
dargs |
Os resultados das chamadas para decay_copy(forward<ArgsTypes>(args...)) . |
Ty |
O tipo result_of<Fn(ArgTypes...)>::type . |
A primeira função de modelo retorna async(launch::any, fn, args...)
.
A segunda função retorna um objeto future<Ty>
cujo estado assíncrono associado contém um resultado em conjunto com os valores de dfn
e dargs
, bem como um objeto de thread para gerenciar um thread de execução separado.
A menos que decay<Fn>::type
não seja do tipo launch, a segunda função não participará da resolução da sobrecarga.
O padrão C++ afirma que, se a política for launch::async
, a função se comportará como se invocasse o objeto chamável em um novo thread. Isso significa que, embora normalmente resulte na criação de um novo thread, a implementação pode usar outros mecanismos para obter um comportamento equivalente. No entanto, a implementação da Microsoft atualmente não está em conformidade estritamente com esse comportamento. Ele obtém seus threads do Windows ThreadPool, que pode fornecer um thread reciclado em vez de um novo. Isso significa que a política é efetivamente implementada launch::async
como launch::async|launch::deferred
. Outra implicação da implementação baseada em ThreadPool é que não há garantia de que as variáveis thread-local serão destruídas quando o thread for concluído. Se o thread for reciclado e fornecido para uma nova chamada a async
, as variáveis antigas ainda existirão. Recomendamos que você evite usar variáveis locais de thread com async
.
Se a política for launch::deferred
, a função marcará seu estado assíncrono associado como contendo uma função adiada e será retornada. A primeira chamada para qualquer função não temporizada que aguarda que o estado assíncrono associado fique pronto chama a função adiada avaliando INVOKE(dfn, dargs..., Ty)
.
Em todos os casos, o estado assíncrono associado do objeto future
não é definido como ready até que a avaliação de INVOKE(dfn, dargs..., Ty)
seja concluída, seja lançando uma exceção ou retornando normalmente. O resultado do estado assíncrono associado é uma exceção se uma tiver sido gerada ou qualquer valor que for retornado pela avaliação.
Observação
Para um future
, ou o último shared_future
, anexado a uma tarefa iniciada com std::async
, o destruidor é bloqueado se a tarefa não tiver sido concluída, ou seja, ele é bloqueado se esse thread ainda não tiver chamado .get()
ou .wait()
e a tarefa ainda estiver em execução. Se um future
obtido de std::async
for movido para fora do escopo local, outro código que o utiliza deve estar ciente de que seu destruidor pode ser bloqueado para que o estado compartilhado fique pronto.
A pseudo função INVOKE
é definida em <functional>
.
Seção específica da Microsoft
Quando a função passada é executada de modo assíncrono, ela é executada no Pool de Threads do Windows. Confira Pools de Thread. O número de threads simultâneos é limitado ao padrão do pool de threads (atualmente 500). O número de threads executados simultaneamente no hardware atualmente é limitado pelo número de processadores lógicos no grupo do processador do processo, portanto, ele é efetivamente limitado a 64. Confira Grupos do processador.
future_category
Retorna uma referência ao objeto error_category que caracteriza erros associados a objetos future
.
const error_category& future_category() noexcept;
make_error_code
Cria um error_code com o objeto error_category que caracteriza erros de future.
inline error_code make_error_code(future_errc Errno) noexcept;
Parâmetros
Errno
Um valor de future_errc que identifica o erro relatado.
Valor de retorno
error_code(static_cast<int>(Errno), future_category());
make_error_condition
Cria um error_condition com o objeto error_category que caracteriza erros de future.
inline error_condition make_error_condition(future_errc Errno) noexcept;
Parâmetros
Errno
Um valor de future_errc que identifica o erro relatado.
Valor de retorno
error_condition(static_cast<int>(Errno), future_category());
swap
Troca o estado assíncrono associado de um objeto promise
pelo de outro objeto.
template <class Ty>
void swap(promise<Ty>& Left, promise<Ty>& Right) noexcept;
template <class Ty, class... ArgTypes>
void swap(packaged_task<Ty(ArgTypes...)>& Left, packaged_task<Ty(ArgTypes...)>& Right) noexcept;
Parâmetros
Left
O objeto promise
à esquerda.
Right
O objeto promise
à direita.