Computador multitarefa

Sistemas operacionais de desktop modernos são capazes de lidar com um grande número de processos diferentes ao mesmo tempo. Esta captura de tela mostra Linux Mint rodando simultaneamente ambiente de desktop Xfce, Firefox, um programa de calculadora, o calendário integrado, Vim, GIMP e leitor de mídia VLC.

Multitarefa da Microsoft Windows 1.01 lançado em 1985, aqui mostrado executando os programas MS-DOS Executive e Calculator

Na computação, multitarefa é a execução simultânea de várias tarefas (também conhecidas como processos) durante um determinado período de tempo. Novas tarefas podem interromper as já iniciadas antes de terminarem, em vez de esperar que terminem. Como resultado, um computador executa segmentos de várias tarefas de maneira intercalada, enquanto as tarefas compartilham recursos de processamento comuns, como unidades centrais de processamento (CPUs) e memória principal. A multitarefa interrompe automaticamente o programa em execução, salvando seu estado (resultados parciais, conteúdo da memória e conteúdo do registro do computador) e carregando o estado salvo de outro programa e transferindo o controle para ele. Essa "mudança de contexto" pode ser iniciado em intervalos de tempo fixos (multitarefa preventiva), ou o programa em execução pode ser codificado para sinalizar ao software de supervisão quando ele pode ser interrompido (multitarefa cooperativa).

Multitarefa não requer execução paralela de várias tarefas exatamente ao mesmo tempo; em vez disso, permite que mais de uma tarefa avance em um determinado período de tempo. Mesmo em computadores com multiprocessadores, a multitarefa permite que muito mais tarefas sejam executadas do que CPUs.

A multitarefa é um recurso comum dos sistemas operacionais de computador desde pelo menos a década de 1960. Permite o uso mais eficiente do hardware do computador; quando um programa está esperando por algum evento externo, como uma entrada do usuário ou uma transferência de entrada/saída com um periférico, o processador central ainda pode ser usado com outro programa. Em um sistema de compartilhamento de tempo, vários operadores humanos usam o mesmo processador como se fosse dedicado a seu uso, enquanto nos bastidores o computador atende a muitos usuários realizando multitarefas em seus programas individuais. Em sistemas de multiprogramação, uma tarefa é executada até que precise esperar por um evento externo ou até que o agendador do sistema operacional forçosamente troque a tarefa em execução da CPU. Sistemas de tempo real, como os projetados para controlar robôs industriais, requerem processamento oportuno; um único processador pode ser compartilhado entre os cálculos de movimento da máquina, comunicações e interface do usuário.

Muitas vezes, os sistemas operacionais multitarefa incluem medidas para alterar a prioridade de tarefas individuais, de modo que trabalhos importantes recebam mais tempo de processamento do que aqueles considerados menos significativos. Dependendo do sistema operacional, uma tarefa pode ser tão grande quanto um programa aplicativo inteiro ou pode ser composta de threads menores que executam partes do programa como um todo.

Um processador destinado ao uso com sistemas operacionais multitarefa pode incluir hardware especial para suportar com segurança várias tarefas, como proteção de memória e anéis de proteção que garantem que o software de supervisão não seja danificado ou subvertido por erros de programa no modo de usuário.

O termo "multitarefa" tornou-se um termo internacional, pois a mesma palavra é usada em muitos outros idiomas, como alemão, italiano, holandês, romeno, tcheco, dinamarquês e norueguês.

Multiprogramação

Nos primórdios da computação, o tempo da CPU era caro e os periféricos eram muito lentos. Quando o computador executava um programa que precisava de acesso a um periférico, a unidade central de processamento (CPU) tinha que parar de executar as instruções do programa enquanto o periférico processava os dados. Isso geralmente era muito ineficiente.

O primeiro computador a usar um sistema de multiprogramação foi o britânico Leo III de J. Lyons and Co. Durante o processamento em lote, vários programas diferentes foram carregados na memória do computador, e o primeiro começou a correr. Quando o primeiro programa alcançou uma instrução esperando por um periférico, o contexto desse programa foi armazenado e o segundo programa na memória teve a chance de ser executado. O processo continuou até que todos os programas terminassem de ser executados.

O uso da multiprogramação foi aprimorado com a chegada da memória virtual e da tecnologia da máquina virtual, que permitia que programas individuais fizessem uso da memória e dos recursos do sistema operacional como se outros programas em execução simultânea fossem, para todos os propósitos práticos, inexistentes.

A multiprogramação não garante que um programa será executado no tempo certo. De fato, o primeiro programa pode muito bem rodar por horas sem precisar de acesso a um periférico. Como não havia usuários esperando em um terminal interativo, isso não era problema: os usuários entregavam um baralho de cartões perfurados a um operador e voltavam algumas horas depois para obter os resultados impressos. A multiprogramação reduziu bastante os tempos de espera quando vários lotes estavam sendo processados.

Multitarefa cooperativa

Os primeiros sistemas multitarefa usavam aplicativos que cediam tempo voluntariamente uns aos outros. Essa abordagem, que acabou sendo suportada por muitos sistemas operacionais de computador, é conhecida hoje como multitarefa cooperativa. Embora agora raramente seja usado em sistemas maiores, exceto para aplicativos específicos, como CICS ou o subsistema JES2, a multitarefa cooperativa já foi o único esquema de agendamento empregado pelo Microsoft Windows e Mac OS clássico para permitir que vários aplicativos sejam executados simultaneamente. A multitarefa cooperativa ainda é usada hoje em sistemas RISC OS.

Como um sistema multitarefa cooperativo depende de cada processo regularmente cedendo tempo para outros processos no sistema, um programa mal projetado pode consumir todo o tempo da CPU para si mesmo, realizando cálculos extensivos ou esperando; ambos fariam todo o sistema travar. Em um ambiente de servidor, esse é um risco que torna todo o ambiente inaceitavelmente frágil.

Multitarefa preventiva

Kubuntu (KDE Plasma 5) quatro desktops virtuais executando vários programas ao mesmo tempo.

A multitarefa preventiva permite que o sistema do computador garanta de forma mais confiável a cada processo uma "fatia" de tempo de operação. Também permite que o sistema lide rapidamente com eventos externos importantes, como entrada de dados, que podem exigir a atenção imediata de um ou outro processo. Os sistemas operacionais foram desenvolvidos para aproveitar esses recursos de hardware e executar vários processos preventivamente. A multitarefa preemptiva foi implementada no PDP-6 Monitor e Multics em 1964, no OS/360 MFT em 1967 e no Unix em 1969, e estava disponível em alguns sistemas operacionais para computadores tão pequenos quanto o PDP-8 da DEC; é um recurso central de todos os sistemas operacionais do tipo Unix, como Linux, Solaris e BSD com seus derivados, bem como versões modernas do Windows.

Em qualquer momento específico, os processos podem ser agrupados em duas categorias: aqueles que estão esperando por entrada ou saída (chamados de "limitação de E/S") e aqueles que estão utilizando totalmente a CPU (&# 34;CPU vinculado"). Em sistemas primitivos, o software geralmente "pesquisa", ou "ocupadoespera" enquanto espera pela entrada solicitada (como entrada de disco, teclado ou rede). Durante esse tempo, o sistema não estava realizando um trabalho útil. Com o advento das interrupções e da multitarefa preemptiva, os processos vinculados à E/S podem ser "bloqueados" ou colocados em espera, aguardando a chegada dos dados necessários, permitindo que outros processos utilizem a CPU. Como a chegada dos dados solicitados geraria uma interrupção, os processos bloqueados poderiam ter a garantia de um retorno oportuno à execução.

O primeiro sistema operacional multitarefa preemptivo disponível para usuários domésticos foi o Sinclair QDOS no Sinclair QL, lançado em 1984, mas poucas pessoas compraram a máquina. O Amiga da Commodore, lançado no ano seguinte, foi o primeiro computador doméstico comercialmente bem-sucedido a usar a tecnologia, e suas habilidades multimídia o tornam um ancestral claro dos computadores pessoais multitarefa contemporâneos. A Microsoft fez da multitarefa preemptiva um recurso central de seu sistema operacional principal no início dos anos 1990, ao desenvolver o Windows NT 3.1 e depois o Windows 95. Em 1988, a Apple ofereceu o A/UX como uma alternativa baseada em UNIX System V ao Mac OS clássico. Em 2001, a Apple mudou para o Mac OS X influenciado pelo NeXTSTEP.

Um modelo semelhante é usado no Windows 9x e na família Windows NT, onde os aplicativos nativos de 32 bits são multitarefa preventivamente. As edições de 64 bits do Windows, tanto para as arquiteturas x86-64 quanto Itanium, não oferecem mais suporte a aplicativos legados de 16 bits e, portanto, fornecem multitarefa preventiva para todos os aplicativos compatíveis.

Tempo real

Outra razão para a multitarefa foi no projeto de sistemas de computação em tempo real, onde há uma série de atividades externas possivelmente não relacionadas que precisam ser controladas por um sistema de processador único. Em tais sistemas, um sistema de interrupção hierárquico é associado à priorização de processos para garantir que as atividades-chave recebam uma parcela maior do tempo de processo disponível.

Multithreading

Como a multitarefa melhorou muito o rendimento dos computadores, os programadores começaram a implementar aplicativos como conjuntos de processos cooperativos (por exemplo, um processo reunindo dados de entrada, um processo processando dados de entrada, um processo gravando os resultados no disco). Isso, no entanto, exigia algumas ferramentas para permitir que os processos trocassem dados com eficiência.

Threads nasceram da ideia de que a maneira mais eficiente de cooperar processos para trocar dados seria compartilhar todo o espaço de memória. Assim, as threads são efetivamente processos que executam no mesmo contexto de memória e compartilham outros recursos com seus processos pais, como arquivos abertos. Threads são descritos como processos leves porque alternar entre threads não envolve alterar o contexto da memória.

Enquanto as threads são agendadas preventivamente, alguns sistemas operacionais fornecem uma variante das threads, denominadas fibras, que são agendadas cooperativamente. Em sistemas operacionais que não fornecem fibras, um aplicativo pode implementar suas próprias fibras usando chamadas repetidas para funções de trabalho. As fibras são ainda mais leves do que os threads e um pouco mais fáceis de programar, embora tendam a perder alguns ou todos os benefícios dos threads em máquinas com vários processadores.

Alguns sistemas suportam diretamente multithreading no hardware.

Proteção de memória

Essencial para qualquer sistema multitarefa é compartilhar o acesso aos recursos do sistema de forma segura e eficaz. O acesso à memória deve ser estritamente gerenciado para garantir que nenhum processo possa ler ou gravar inadvertida ou deliberadamente em locais de memória fora do espaço de endereço do processo. Isso é feito para fins de estabilidade geral do sistema e integridade dos dados, bem como para a segurança dos dados.

Em geral, o gerenciamento de acesso à memória é de responsabilidade do kernel do sistema operacional, em combinação com mecanismos de hardware que fornecem funcionalidades de suporte, como uma unidade de gerenciamento de memória (MMU). Se um processo tentar acessar um local de memória fora de seu espaço de memória, a MMU nega a solicitação e sinaliza ao kernel para tomar as ações apropriadas; isso geralmente resulta no encerramento forçado do processo ofensivo. Dependendo do design do software e do kernel e do erro específico em questão, o usuário pode receber uma mensagem de erro de violação de acesso, como "falha de segmentação".

Em um sistema multitarefa bem projetado e implementado corretamente, um determinado processo nunca pode acessar diretamente a memória que pertence a outro processo. Uma exceção a essa regra é no caso de memória compartilhada; por exemplo, no mecanismo de comunicação entre processos do System V, o kernel aloca memória para ser compartilhada mutuamente por vários processos. Esses recursos são frequentemente usados por software de gerenciamento de banco de dados, como o PostgreSQL.

Mecanismos de proteção de memória inadequados, devido a falhas em seu design ou implementações inadequadas, permitem vulnerabilidades de segurança que podem ser potencialmente exploradas por software malicioso.

Troca de memória

O uso de um arquivo de troca ou partição de troca é uma maneira de o sistema operacional fornecer mais memória do que está fisicamente disponível, mantendo partes da memória primária no armazenamento secundário. Embora a multitarefa e a troca de memória sejam duas técnicas completamente não relacionadas, elas são frequentemente usadas juntas, pois a troca de memória permite que mais tarefas sejam carregadas ao mesmo tempo. Normalmente, um sistema multitarefa permite que outro processo seja executado quando o processo em execução atinge um ponto em que precisa esperar que alguma parte da memória seja recarregada do armazenamento secundário.

Programação

Processos totalmente independentes não são muito problemáticos para programar em um ambiente multitarefa. A maior parte da complexidade em sistemas multitarefa vem da necessidade de compartilhar recursos de computador entre tarefas e sincronizar a operação de tarefas cooperativas.

Várias técnicas de computação simultânea são usadas para evitar possíveis problemas causados por várias tarefas tentando acessar o mesmo recurso.

Sistemas maiores às vezes eram construídos com um(s) processador(es) central(is) e algum número de processadores de E/S, um tipo de multiprocessamento assimétrico.

Ao longo dos anos, os sistemas multitarefa foram refinados. Os sistemas operacionais modernos geralmente incluem mecanismos detalhados para priorizar processos, enquanto o multiprocessamento simétrico introduziu novas complexidades e capacidades.