Contextos

Este documento descreve a função dos contextos no Runtime de simultaneidade. Um segmento 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 dos contextos. Use o wait a função de suspender o contexto atual para um horário especificado. Use o Context classe quando você precisar de mais controle sobre quando bloqueiam, desbloquear e contextos rendimento, ou quando você deseja receber assinaturas demais o contexto atual.

Dica

O Runtime de simultaneidade fornece um programador de padrão e, portanto, não é necessário criá-lo em seu aplicativo. Como o Agendador de tarefas Ajuda a ajustar o desempenho de seus aplicativos, recomendamos que você inicie com o Biblioteca paralela de padrões (PPL) ou Biblioteca de agentes assíncronos se você for novo no 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 tempo de execução usa o horário 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.

Passando a 0 (zero) para o milliseconds parâmetro faz com que o tempo de execução suspender o contexto atual até que todos os outros contextos active terá a oportunidade de realizar o trabalho. Isso permite que você 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 outros contextos de execução, consulte Como: Use grupos de agendamento para influenciar a ordem de execução.

A classe de contexto

O Concurrency::Context classe fornece uma abstração de programação para o contexto de execução e oferece dois recursos importantes: a capacidade de forma cooperativa bloquear, desbloquear e gerar o contexto atual 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 de bloqueados. O Context::Unblock método deve ser chamado a partir de um contexto diferente daquele que é chamado Context::Block. O runtime 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 o objeto que está associado ao segmento atual e salva o resultado. Em seguida, chamar o Context::Block método para bloquear o contexto atual. Mais tarde, chamar Context::Unblock a partir de um contexto separado para desbloquear o contexto bloqueados.

Você deve fazer a correspondência de cada par de chamadas para Context::Block e Context::Unblock. O runtime lança Concurrency::context_unblock_unbalanced quando o Context::Block ou Context::Unblock método é chamado consecutivamente sem uma chamada correspondente para o outro método. No entanto, você não precisará chamar Context::Block antes de chamar Context::Unblock. Por exemplo, se chama de um contexto Context::Unblock antes de outra chamada de contexto Context::Block no mesmo contexto, esse contexto permanecerá desbloqueado.

O Concurrency::Context::Yield método resulta em execução para que o runtime possa realizar outras tarefas e reagendar o contexto de execução. Quando você chama 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.

Assinatura excessiva

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

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

Observação

Habilite o excesso de assinatura apenas a partir de um thread não UMS que foi criado pelo Runtime de simultaneidade. Excesso de assinatura não tem efeito quando ele é chamado de um segmento que não foi criado pelo tempo de execução (incluindo o thread principal). Além disso, excesso de assinatura não tem efeito quando ele é chamado de um contexto que usa os threads UMS para agendar tarefas, pois os threads UMS ativar o Agendador usar totalmente os recursos na presença de bloqueio de operações.

Para habilitar o excesso de assinaturas no contexto atual, chame 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 assinaturas, chame Context::Oversubscribe com o _BeginOversubscription parâmetro definido como false.

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

Observação
O runtime lança Concurrency::invalid_oversubscribe_operation se oversubscription for desativado, antes que ele está habilitado.

Exemplo

Para obter um exemplo que usa o excesso de assinatura para compensar a latência causada por leitura de dados de uma conexão de rede, consulte Como: Use o excesso de assinatura para deslocamento latência.

Consulte também

Tarefas

Como: Use o excesso de assinatura para deslocamento latência

Conceitos

Agendador de tarefas (Runtime de simultaneidade)

Outros recursos

Como: Use grupos de agendamento para influenciar a ordem de execução

Como: Use a classe de contexto para implementar um semáforo cooperativo

Histórico de alterações

Date	History	Motivo
Julho de 2010	Conteúdo reorganizado.	Aprimoramento de informações.