Para explicar mais, suponha que temos uma CPU dual core sem hyper threading, o que significa que ela pode processar apenas 2 threads ao mesmo tempo, bem, agora suponha que temos um aplicativo de rede que está executando dois threads de rede em segundo plano, cada um esperando por conexões de entrada para lidar, então esses threads deveriam estar rodando o tempo todo, agora, por que os processos e threads do outro sistema operacional ainda estão funcionando?! pelo que me parece, eles não podem ser processados porque existem dois threads que drenam totalmente a unidade de processamento da CPU porque estão aguardando conexões de entrada da rede e, portanto, devem estar prontos a cada nanossegundo para conexões ... Como isso acontece e funciona? Como a CPU pode lidar com muitos e muitos threads ao mesmo tempo sem nenhum congelamento perceptível?! (Eu sei que, às vezes, o Windows fica lento e louco se houver muitos programas pesados em execução ao mesmo tempo, mas isso não é um problema geral)
Obrigado.
Responder1
A resposta é relativamente simples: quando um thread está aguardando um evento de E/S, ele cede o restante de seu intervalo de tempo ao sistema operacional, que pode então agendar outro thread. Quando a E/S de alta latência for concluída, o thread será marcado como pronto para execução.
Isso é amplamente possível porque a maior parte da E/S é gerenciada com interrupções, em vez de verificar repetidamente se a solicitação de E/S foi concluída (conhecido como polling).
Responder2
Se você usa multitarefa cooperativa e tem um programa ruim: então sim, você está certo.
No entanto, no mundo real, o seguinte deveria acontecer:
Multitarefa cooperativa: Eu não uso a CPU para sempre. Em vez disso, dará uma chance a outro programa depois de algum tempo ou quando for bloqueado.
A resposta de Paulo descreve o último.Multitarefa preemptiva (usada em quase todos os lugares): O sistema operacional (não o programa) fornecerá a CPU por um curto período de tempo para um programa e depois a retirará. Isso pode ser tão simplista quanto executar um cronômetro e, quando ele expirar, interromper o processo e entregá-lo à próxima etapa/programa que estiver aguardando.
No seu caso, pense nisso como um escritório com dois funcionários e três (ou mais) tarefas. (Vamos chamá-los de tarefa-A, tarefa-B e tarefa-C).
O primeiro trabalhado verifica as ordens dos supervisores que determinam:
- Defina um cronômetro para 10 minutos. Quando ele desligar, pare de trabalhar em sua tarefa atual, coloque-a no final da lista TODO e continue lendo este documento.
- Em seguida, remova o primeiro item do topo da lista TODO e comece a trabalhar nele.
- Repita.
O trabalhador 1 configura o cronômetro e obtém a primeira tarefa da lista TODO (neste caso, a tarefa A).
O trabalhador 2 faz a mesma coisa: define um cronômetro e obtém o que está agora no topo da lista TODO. Como o trabalhador 1 removeu a tarefa A dele, o trabalhador 2 agora inicia na tarefa B.
Dez minutos depois o cronômetro dispara. O trabalhador 1 para de trabalhar na Tarefa A e recebe as instruções dos supervisores. Esses estados devem colocar a tarefa atual no final da lista TODO. Continuando as instruções do supervisor, ele reinicia o cronômetro e começa a trabalhar no que está agora no topo da lista TODO (que é a tarefa-C).
O trabalhador 2 faz o mesmo e interrompe a tarefa B e começa no topo da lista TODO (que no exemplo é a tarefa A)
Etc etc..
Isso é um tanto simplificado. Mas deve dar uma ideia de como dois passos (trabalhadores) podem trabalhar 100% do tempo em três ou mais tarefas.
Em agendadores reais, há muito mais coisas. Por exemplo, interrupções (compare com um telefone tocando no meio de uma tarefa e como lidar com isso), agendamento inteligente (dar a mesma tarefa ao mesmo trabalhador provavelmente resultará em uma conclusão mais rápida, uma vez que o trabalhador já está familiarizado com ela) , E/S (se um trabalhador precisar de um livro de uma biblioteca, ele não esperará até que o cronômetro expire, mas continuará imediatamente com a próxima tarefa, etc., etc.
Responder3
O sistema operacional permanece estável praticamente da mesma maneira que permanece estável quando há vários threads em execução em CPUs diferentes. Fora do núcleo da CPU, há muito pouca diferença aparente no comportamento entre dois LPs no mesmo núcleo e um LP em cada um dos dois núcleos diferentes. Todas as mesmas técnicas de programação "seguras para multiprocessador", como semáforos, devem ser usadas em ambos os casos.