Contextos

Artigo
02/25/2013

Este documento descreve a função de contextos no Runtime de simultaneidade.Um thread que está conectado a um agendador é conhecido como um o contexto de execução, ou apenas contexto.O concurrency::wait função e o concurrency::Context classe permitem controlar o comportamento de contextos.Use o wait função suspender o contexto atual para um horário especificado.Use o Context classe quando precisar de mais controle sobre quando contextos bloquear, desbloquear e produzam ou quando você deseja receber assinaturas demais o contexto atual.

Dica
O Runtime de simultaneidade oferece um agendador padrão e, portanto, não é necessário criar um em seu aplicativo.Como o Agendador de tarefas Ajuda a ajustar o desempenho de seus aplicativos, recomendamos que você inicie com o A modelos paralela a biblioteca (PPL) ou Biblioteca de agentes assíncrono se você for novo para o Runtime de simultaneidade.

A função de espera

O concurrency::wait função cooperativa gera a execução do contexto atual para um número especificado de milissegundos.O runtime usa o tempo de rendimento para executar outras tarefas.Após decorrido o tempo especificado, o runtime reagenda o contexto de execução.Portanto, o wait função pode suspender o contexto atual mais do que o valor fornecido para o milliseconds parâmetro.

Passar 0 (zero) o milliseconds parâmetro faz com que o tempo de execução suspender o contexto atual até que todos os outros contextos ativos terá a oportunidade de realizar o trabalho.Permite gerar uma tarefa para todas as outras tarefas ativas.

Exemplo

Para obter um exemplo que usa o wait função para gerar o contexto atual e assim permitir para outros contextos de execução, consulte Como: Use grupos de cronograma para influenciar a ordem de execução.

A classe de contexto

O concurrency::Context classe fornece uma abstração de programação para um contexto de execução e oferece dois recursos importantes: a capacidade de bloquear, desbloquear e produzir o contexto atual cooperativa e a capacidade de receber assinaturas demais o contexto atual.

Bloqueio cooperativo

O Context classe permite bloquear ou gerar o contexto de execução atual.Bloqueando ou produzindo é útil quando o contexto atual não pode continuar porque um recurso não está disponível.

O concurrency::Context::Block método bloqueia o contexto atual.Um contexto que está bloqueado produz seus recursos de processamento para que o runtime possa realizar outras tarefas.O concurrency::Context::Unblock método desbloqueia um contexto bloqueado.O Context::Unblock método deve ser chamado em um contexto diferente daquele que chamado Context::Block.O tempo de execução lança concurrency::context_self_unblock se um contexto de tentar se desbloquear.

Cooperativa bloquear e desbloquear um contexto, você normalmente chama concurrency::Context::CurrentContext para recuperar um ponteiro para o Context objeto que está associado com o thread atual e salvar o resultado.Em seguida, chame o Context::Block método para bloquear o contexto atual.Mais tarde, chamar Context::Unblock de um contexto separado para desbloquear o contexto bloqueado.

Você precisa coincidir cada par de chamadas para Context::Block e Context::Unblock.O tempo de execução lança concurrency::context_unblock_unbalanced quando a Context::Block ou Context::Unblock método é chamado consecutivamente sem uma chamada correspondente para o outro método.Entretanto, não é necessário chamar Context::Block antes de chamar Context::Unblock.Por exemplo, se um contexto chama Context::Unblock antes de outro contexto chamadas Context::Block no mesmo contexto, que o contexto permanecerá desbloqueado.

O concurrency::Context::Yield método resulta em execução para que o runtime pode executar outras tarefas e, em seguida, reagendar o contexto de execução.Quando você chamar o Context::Block método, o runtime não reagendar o contexto.

Exemplo

Para obter um exemplo que usa o Context::Block, Context::Unblock, e Context::Yield métodos para implementar uma classe semaphore cooperativo, consulte Como: Use a classe de contexto para implementar um semáforo cooperativo.

Excesso de assinatura

O agendador padrão cria o mesmo número de segmentos como segmentos de hardware disponíveis.Você pode usar oversubscription para criar segmentos adicionais para um segmento de determinado hardware.

Para operações computacionais intensas, excesso de assinatura normalmente não dimensionar porque ele apresenta uma sobrecarga adicional.No entanto, para tarefas que têm uma grande quantidade de latência, por exemplo, dados de leitura de disco ou de uma conexão de rede oversubscription pode melhorar a eficiência geral de alguns aplicativos.

Observação
Habilite oversubscription apenas de um segmento que foi criado pelo Runtime de simultaneidade.Excesso de assinatura não tem efeito quando ele é chamado de um thread que não foi criado pelo tempo de execução (incluindo o thread principal).

Para habilitar o excesso de assinaturas no contexto atual, chamar o concurrency::Context::Oversubscribe método com o _BeginOversubscription parâmetro definido como true.Quando você habilita o excesso de assinatura em um thread que foi criado pelo Runtime de simultaneidade, faz com que o tempo de execução criar um segmento adicional.Após todas as tarefas que exigem o término de excesso de assinatura, chamada Context::Oversubscribe com o _BeginOversubscription parâmetro definido como false.

Você pode habilitar oversubscription várias vezes do contexto atual, mas você deve desativar o mesmo número de vezes que você ativá-lo.Excesso de assinaturas também pode ser aninhado; receber assinaturas, isto é, uma tarefa é criada por outra tarefa usa oversubscription pode também demais seu contexto.No entanto, se uma tarefa aninhada e seu pai pertencem ao mesmo contexto, somente a chamada externa para Context::Oversubscribe faz com que a criação de um segmento adicional.

Observação
O tempo de execução lança concurrency::invalid_oversubscribe_operation se oversubscription é desativado antes de ser ativada.

Exemplo

Para obter um exemplo que usa o excesso de assinatura para compensar a latência causada pela leitura de dados de uma conexão de rede, consulte Como: use a sobresubscrição para deslocar a latência.