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 criará um novo thread. No entanto, a implementação da Microsoft atualmente não está em conformidade. Ela obtém seus threads do Windows ThreadPool, que em alguns casos podem fornecer um thread reciclado em vez de um novo. Isso significa que a política launch::async é implementada 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ê não use variáveis thread-local 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 Devolução

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 Devolução

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.

Confira também

<future>