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
policy
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 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 locais de thread sejam destruídas quando o thread for concluído. Se o thread for reciclado e fornecido para uma nova chamada para async, as variáveis antigas ainda existirão. Recomendamos que você evite usar variáveis locais de thread com async.
Se policy for launch::deferred, a função marcará seu estado assíncrono associado como contendo uma adiada função e será retornada. A primeira chamada para qualquer função não cronometrada que aguarda que o estado assíncrono associado esteja pronto na verdade 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 um foi lançado ou o valor que a avaliação retorna.
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>.
específica da Microsoft
Quando a função passada é executada de forma assíncrona, ela é executada no Pool de Threads do Windows. Para obter mais informações, consulte Pools de threads. O número de threads simultâneos é limitado ao padrão do pool de threads, que é de 500 threads.
Antes do Windows 11 e do Windows Server 2022, os aplicativos eram limitados por padrão a um único grupo de processadores com no máximo 64 processadores lógicos. Isso limitou o número de threads em execução simultânea a 64. Para obter mais informações, consulte Grupos de processadores.
A partir do Windows 11 e do Windows Server 2022, os processos e seus threads têm afinidades de processador que, por padrão, abrangem todos os processadores no sistema e em vários grupos em computadores com mais de 64 processadores. O limite do número de threads simultâneos agora é o número total de processadores lógicos no sistema.
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 future_errc valor que identifica o erro relatado.
Valor de retorno
error_code(static_cast<int>(Errno), future_category());
make_error_condition
Cria um error_condition conjunto com o error_category objeto que caracteriza future os erros.
inline error_condition make_error_condition(future_errc Errno) noexcept;
Parâmetros
Errno
Um future_errc valor 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.