Prioridades de agendamento
Os threads são agendados para serem executados com base em sua prioridade de agendamento. Cada thread recebe uma prioridade de agendamento. Os níveis de prioridade variam de zero (prioridade mais baixa) a 31 (prioridade mais alta). Somente o thread de página zero pode ter uma prioridade de zero. (O thread de página zero é um thread do sistema responsável por zerar as páginas gratuitas quando não há outros threads que precisem ser executados.)
O sistema trata todos os threads com a mesma prioridade que igual. O sistema atribui fatias de tempo de forma round robin a todos os threads com a prioridade mais alta. Se nenhum desses threads estiver pronto para execução, o sistema atribuirá fatias de tempo de forma round robin a todos os threads com a próxima prioridade mais alta. Se um thread de prioridade mais alta ficar disponível para execução, o sistema deixará de executar o thread de prioridade mais baixa (sem permitir que ele termine de usar sua fatia de tempo) e atribuirá uma fatia em tempo integral ao thread de prioridade mais alta. Para obter mais informações, consulte Opções de contexto.
A prioridade de cada thread é determinada pelos seguintes critérios:
- A classe prioritária de seu processo
- O nível de prioridade do thread dentro da classe de prioridade de seu processo
A classe de prioridade e o nível de prioridade são combinados para formar a prioridade base de um thread. Para obter informações sobre a prioridade dinâmica de um thread, consulte Aumentos de prioridade.
Classe Priority
Cada processo pertence a uma das seguintes classes prioritárias:
- IDLE_PRIORITY_CLASS
BELOW_NORMAL_PRIORITY_CLASS
NORMAL_PRIORITY_CLASS
ABOVE_NORMAL_PRIORITY_CLASS
HIGH_PRIORITY_CLASS
REALTIME_PRIORITY_CLASS
Por padrão, a classe de prioridade de um processo é NORMAL_PRIORITY_CLASS. Use a função CreateProcess para especificar a classe de prioridade de um processo filho ao criá-la. Se o processo de chamada for IDLE_PRIORITY_CLASS ou BELOW_NORMAL_PRIORITY_CLASS, o novo processo herdará essa classe. Use a função GetPriorityClass para determinar a classe de prioridade atual de um processo e a função SetPriorityClass para alterar a classe de prioridade de um processo.
Processos que monitoram o sistema, como poupadores de tela ou aplicativos que atualizam periodicamente uma exibição, devem usar IDLE_PRIORITY_CLASS. Isso impede que os threads desse processo, que não têm alta prioridade, interfiram em threads de prioridade mais alta.
Use HIGH_PRIORITY_CLASS com cuidado. Se um thread for executado no nível de prioridade mais alto por períodos estendidos, outros threads no sistema não terão tempo de processador. Se vários threads forem definidos com alta prioridade ao mesmo tempo, os threads perderão sua eficácia. A classe de alta prioridade deve ser reservada para threads que devem responder a eventos críticos de tempo. Se o aplicativo executar uma tarefa que exija a classe de alta prioridade enquanto o restante de suas tarefas for prioridade normal, use SetPriorityClass para aumentar temporariamente a classe de prioridade do aplicativo; em seguida, reduza-a depois que a tarefa crítica tiver sido concluída. Outra estratégia é criar um processo de alta prioridade que tenha todos os threads bloqueados na maior parte do tempo, despertando threads somente quando tarefas críticas forem necessárias. O ponto importante é que um thread de alta prioridade deve ser executado por um breve período e somente quando ele tem trabalho crítico de tempo para executar.
Você quase nunca deve usar REALTIME_PRIORITY_CLASS, pois isso interrompe os threads do sistema que gerenciam a entrada do mouse, a entrada do teclado e a liberação de disco em segundo plano. Essa classe pode ser apropriada para aplicativos que "conversam" diretamente com hardware ou que executam tarefas breves que devem ter interrupções limitadas.
Nível de prioridade
Veja a seguir os níveis de prioridade em cada classe de prioridade:
- THREAD_PRIORITY_IDLE
THREAD_PRIORITY_LOWEST
THREAD_PRIORITY_BELOW_NORMAL
THREAD_PRIORITY_NORMAL
THREAD_PRIORITY_ABOVE_NORMAL
THREAD_PRIORITY_HIGHEST
THREAD_PRIORITY_TIME_CRITICAL
Todos os threads são criados usando THREAD_PRIORITY_NORMAL. Isso significa que a prioridade do thread é a mesma da classe de prioridade do processo. Depois de criar um thread, use a função SetThreadPriority para ajustar sua prioridade em relação a outros threads no processo.
Uma estratégia típica é usar THREAD_PRIORITY_ABOVE_NORMAL ou THREAD_PRIORITY_HIGHEST para o thread de entrada do processo, para garantir que o aplicativo responda ao usuário. Os threads em segundo plano, particularmente aqueles que têm uso intensivo de processador, podem ser definidos como THREAD_PRIORITY_BELOW_NORMAL ou THREAD_PRIORITY_LOWEST, para garantir que eles possam ser preempcionados quando necessário. No entanto, se você tiver um thread aguardando outro thread com prioridade mais baixa para concluir alguma tarefa, bloqueie a execução do thread de alta prioridade em espera. Para fazer isso, use uma função de espera, uma seção crítica ou a função Sleep , SleepEx ou SwitchToThread . Isso é preferível para que o thread execute um loop. Caso contrário, o processo pode ficar em deadlock, pois o thread com prioridade mais baixa nunca é agendado.
Para determinar o nível de prioridade atual de um thread, use a função GetThreadPriority .
Prioridade de Base
A classe de prioridade de processo e o nível de prioridade do thread são combinados para formar a prioridade base de cada thread.
A tabela a seguir mostra a prioridade base para combinações de classe de prioridade de processo e valor de prioridade de thread.
| Classe de prioridade de processo | Nível de prioridade do thread | Prioridade base | |
|---|---|---|---|
| IDLE_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 2 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 3 | ||
| THREAD_PRIORITY_NORMAL | 4 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 5 | ||
| THREAD_PRIORITY_HIGHEST | 6 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| BELOW_NORMAL_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 4 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 5 | ||
| THREAD_PRIORITY_NORMAL | 6 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 7 | ||
| THREAD_PRIORITY_HIGHEST | 8 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| NORMAL_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 6 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 7 | ||
| THREAD_PRIORITY_NORMAL | 8 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 9 | ||
| THREAD_PRIORITY_HIGHEST | 10 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| ABOVE_NORMAL_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 8 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 9 | ||
| THREAD_PRIORITY_NORMAL | 10 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 11 | ||
| THREAD_PRIORITY_HIGHEST | 12 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| HIGH_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 1 | |
| THREAD_PRIORITY_LOWEST | 11 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 12 | ||
| THREAD_PRIORITY_NORMAL | 13 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 14 | ||
| THREAD_PRIORITY_HIGHEST | 15 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 15 | ||
| REALTIME_PRIORITY_CLASS | THREAD_PRIORITY_IDLE | 16 | |
| THREAD_PRIORITY_LOWEST | 22 | ||
| THREAD_PRIORITY_BELOW_NORMAL | 23 | ||
| THREAD_PRIORITY_NORMAL | 24 | ||
| THREAD_PRIORITY_ABOVE_NORMAL | 25 | ||
| THREAD_PRIORITY_HIGHEST | 26 | ||
| THREAD_PRIORITY_TIME_CRITICAL | 31 | ||
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de