Contextos
Este documento descreve a função dos contextos em tempo de execução de simultaneidade. Um thread que é anexado a um agendador é conhecido como um contexto de execução, ou apenas o contexto. A função de concurrency::wait e a classe de concurrency::Context permitem controlar o comportamento dos contextos. Use a função de wait para suspender o contexto atual em um momento específico. Use a classe de Context quando precisar de mais controle sobre quando os contextos bloqueiam, desbloqueiam, e gerenciem, ou quando você deseja gerar oversubscribe o contexto atual.
Dica
O tempo de execução de simultaneidade fornece um agendador padrão, e em virtude disso não é necessário criar um relatório em seu aplicativo.Como o agendador de tarefas o ajuda a ajustar o desempenho dos aplicativos, recomendamos que você comece com Biblioteca de padrões paralelos (PPL) ou Biblioteca de Agentes Assíncronos se você é novato em tempo de execução de simultaneidade.
A função de espera
A função de concurrency::wait gerencie cooperativa a execução do contexto atual para um determinado número de milissegundos. O tempo de execução usa o tempo de desempenho de executar outras tarefas. Depois que o tempo especificado tiver decorrido, o tempo de execução reagendar o contexto da execução. Consequentemente, a função de wait pode suspender o contexto atual por mais tempo que o valor fornecido para o parâmetro de milliseconds .
Passar 0 (zero) para o parâmetro de milliseconds faz com que o tempo de execução suspenda o contexto atual até que todos contextos ativas restantes sejam dados a oportunidade de execução do trabalho. Isso permite gerar uma tarefa a todas as tarefas ativas restantes.
Exemplo
Para obter um exemplo que usa a função de wait para produzir o contexto atual, e isso permite executar outros contextos, consulte Como usar grupos de agendas para influenciar a ordem de execução.
A classe de contexto
A classe de concurrency::Context fornece uma abstração de programação para um contexto de execução e oferece dois recursos importantes: a capacidade de bloqueio cooperativa, desbloquear, e gerencie o contexto atual, e a capacidade de oversubscribe o contexto atual.
Bloqueio cooperativo
A classe de Context permite bloqueio ou gerar o contexto de execução atual. Bloquear ou gerar é útil quando o contexto atual não pode continuar porque um recurso não está disponível.
O método de concurrency::Context::Block bloqueia o contexto atual. Um contexto que é gera bloqueados seus recursos de processamento de modo que o tempo de execução possa executar outras tarefas. O método de concurrency::Context::Unblock desbloqueia um contexto bloqueado. O método de Context::Unblock deve ser chamado de um contexto diferente de aquele que chamou Context::Block. O tempo de execução concurrency::context_self_unblock lançará uma se um contexto tenta se desbloquear.
Para bloquear e desbloquear cooperativa um contexto, você normalmente chama concurrency::Context::CurrentContext para recuperar um ponteiro para o objeto de Context associado ao thread atual e para salvar o resultado. Você pode chamar o método de Context::Block para bloquear o contexto atual. Posteriormente, chame Context::Unblock de um contexto separado para desbloquear o contexto bloqueado.
Você deve corresponder cada par de chamadas a Context::Block e a Context::Unblock. O tempo de execução gerencie concurrency::context_unblock_unbalanced quando o método de Context::Block ou de Context::Unblock é chamado consecutivamente sem uma chamada correspondente em outro método. Porém, você não precisa chamar Context::Block antes de chamar Context::Unblock. Por exemplo, se um contexto chama Context::Unblock antes de chamar outro contexto Context::Block para o mesmo contexto, permanecerá nesse contexto desbloqueadas.
O método de concurrency::Context::Yield gerencie a execução de modo que o tempo de execução possa executar outras tarefas e depois reagendamento o contexto da execução. Quando você chama o método de Context::Block , o tempo de execução não reagendar o contexto.
Exemplo
Para obter um exemplo que usa Context::Block, Context::Unblock, e os métodos de Context::Yield para implementar uma classe cooperativa do sinal, consulte Como usar a classe de contexto para implementar um semáforo cooperativo.
Sobrecarga
O agendador padrão cria o mesmo número de threads como há threads disponíveis de hardware. Você pode usar a sobresubscrição para criar threads adicionais para um determinado thread de hardware.
Para operações computacionalmente intenso, a não sobresubscrição normalmente dimensiona pois apresenta a sobrecarga adicional. No entanto, para as tarefas que têm uma quantidade de alta latência, por exemplo, ler dados de disco ou de uma conexão de rede, a sobresubscrição pode melhorar a eficiência de alguns aplicativos total.
Dica
Habilitar a sobresubscrição de apenas um thread criado em tempo de execução de simultaneidade.A sobresubscrição não tem nenhum efeito quando é chamada de um thread que não seja criado no tempo de execução (que inclui o thread principal).
Para habilitar a sobresubscrição no contexto atual, chame o método de concurrency::Context::Oversubscribe com o parâmetro de _BeginOversubscription definido como true. Quando você habilita a sobresubscrição em um thread que seja criado no tempo de execução de simultaneidade, faz com que o tempo de execução crie um thread adicional. Depois que a tarefa requer o término de sobresubscrição, chame Context::Oversubscribe com o parâmetro de _BeginOversubscription definido como false.
Você pode habilitar a sobresubscrição várias vezes o contexto atual, mas você deve desabilita-o o mesmo número de vezes que você habilita as. A sobresubscrição também pode ser aninhada; ou seja, uma tarefa que é criada por outra tarefa que usa a sobresubscrição também pode oversubscribe seu contexto. No entanto, se uma tarefa aninhada e seu pai pertencem ao mesmo contexto, somente a chamada externo a Context::Oversubscribe causa a criação de um thread adicional.
Dica
O tempo de execução concurrency::invalid_oversubscribe_operation lançará uma se a sobresubscrição é desabilitada até que seja habilitada.
Exemplo
Para obter um exemplo que usa a sobresubscrição para deslocar a latência que é causado ler dados de uma conexão de rede, consulte Como usar excesso de assinatura para deslocar latência.
Consulte também
Tarefas
Como usar grupos de agendas para influenciar a ordem de execução
Como usar a classe de contexto para implementar um semáforo cooperativo
Como usar excesso de assinatura para deslocar latência