Вы находитесь на странице: 1из 10

Objetivo: O Objetivo desta sistematização é apresentar os conceitos básicos sobre as

etapas da gerência de processos e mostrar que é um elemento chave para um sistema


operacional.

Resumo:
O Sistema Operacional é responsável pela supervisão e execução dos programas,
alocando os recursos necessários através do administrador conveniente, e controlando a
utilização da UCP pelos diversos processos. Um sistema operacional pode ser visto
como um programa de grande complexidade que é responsável por todo o
funcionamento de uma máquina desde o software a todo hardware instalado na
máquina. Todos os processos de um computador estão por de trás de uma programação
complexa que comanda todas as funções que um utilizador impõe à máquina.

O gerenciamento de processo é o que coordena a execução das tarefas que são


executadas no sistema operacional, ele faz a interação e organização dos processos.

Processos: O conceito de processo é, certamente, o conceito mais importante no estudo


de sistemas operacionais. Para facilitar o entendimento deste conceito, considere-se um
computador funcionando em multiprogramação (isto é, tendo vários programas
simultaneamente ativos na memória). Processo é o conceito central em qualquer sistema
operacional, uma abstração de um programa em execução, ou seja, o programa é o
código e o processo é a execução.

Processo é Entidade Ativa, ao contrário do programa, que é uma entidade passiva

O processo constitui-se de:


✔ Código executável;
✔ Pilha de Execução;
✔ Dados;
✔ Estado;
✔ Registradores;
✔ Prioridades, arquivos abertos, quotas, etc.

Estrutura do Processo

Um processo é o ambiente onde um programa é executado. Este ambiente, além


das informações sobre a execução, possui também o quanto de recursos do sistema cada
programa pode utilizar, como o espaço de endereçamento, tempo do processador e área
em disco.
Um processo é formado por três partes, conhecidas como contexto de hardware,
contexto de software e espaço de endereçamento, que juntas mantêm todas as
informações necessárias à execução de um programa.

Contexto de Hardware

Armazena o conteúdo dos registradores gerais da UCP, além dos registradores


de uso especifico, como program couter (PC), stack pointer (SP) e registrador de status.
Quando um processo está em execução, o seu contexto de hardware está armazenado
nos registradores do processador. No momento em que o processo perde a utilização da
UCP, o sistema salva as informações no contexto de hardware do processo.
A troca de um processo por outro no processador, comandada pelo sistema
operacional, é denominada mudança de contexto. A mudança de contexto consiste em
salvar o conteúdo dos registradores do processo que está deixando a UCP e carrega-lo
com os valores referentes ao do novo processo que será executado. Essa operação
resume-se em substituir o conteúdo de hardware de um processo pelo de outro.
Mudança de contexto

Contexto de Software

No contexto de software são especificadas características e limites dos recursos


que podem ser alocados pelo processo, como o número máximo de arquivos abertos
simultaneamente, prioridade de execução e tamanho do buffer para operações de E/S. A
maior parte das informações do contexto de software do processo são provenientes de
um arquivo do sistema operacional, conhecido como arquivo de contas. O contexto de
software é composto por três grupos de informações sobre o processo: Identificação,
quotas e privilégios.

Identificação : cada processo criado pelo sistema recebe uma identificação única
representada por um número. O processo também possui a identificação do usuário ou
processo que o criou. Cada usuário possui uma identificação única no sistema, atribuída
ao processo no momento de sua criação.
Quotas: São os limites de cada recurso do sistema que um processo pode alocar. Caso
uma cota seja insuficiente, o processo poderá ser executado lentamente, interrompido
durante seu processamento ou mesmo não ser executado.

Privilégios: ou direitos definem as ações que um processo pode fazer em relação a ele
mesmo, aos demais processos e ao sistema operacional.

Espaço de Endereçamento

É a área do processo responsável em armazenar todas as instruções e dados do


processo em execução. Cada processo possui sua área de endereçamento, devidamente
protegido do acesso dos demais processos.

Estado do Processo

Os processos passam por diferentes estados ao longo do seu processamento, em


função de eventos gerados pelo sistema operacional ou pelo próprio processo. Um
processo ativo pode encontrar-se em três diferentes estados:

Execução (running)
Pronto (ready)
Espera (wait)

Execução (running) – Um processo é dito no estado de execução quando está sendo


processado pela UCP. Em sistemas com apenas uma UCP, somente um processo pode
estar sendo executado em um dado instante. Os processos se alternam na utilização do
processador seguindo uma política estabelecida pelo sistema operacional.
Em sistemas com múltiplos processadores, existe a possibilidade de mais de um
processo estar sendo executado ao mesmo tempo. Neste tipo de sistema, também é
possível um mesmo processo ser executado simultaneamente em mais de uma UCP
(processamento paralelo).

Pronto (ready)

É quando o processo aguarda apenas para ser executado. O sistema operacional é


responsável por determinar a ordem e os critérios pelos quais os processos em estado de
pronto devem fazer uso do processador. Este mecanismo é conhecido como
escalonamento.
Em geral existem vários processos no sistema no estado de pronto organizados
em listas encadeadas. Os processos devem estar ordenados pela sua importância,
permitindo que processos mais prioritários sejam selecionados primeiramente para
execução.

Espera (wait)

É quando o processo que esta aguardando por algum evento externo ou por
algum recurso para prosseguir seu processamento. Como exemplo, podemos citar o
término de uma operação de entrada/saída ou a espera de uma determinada Dara e/ou
hora para continuar sua execução. Em alguns sistemas operacionais, o estado de espera
pode ser chamado de bloqueado (blocked).
O sistema organiza os vários processos no estado de espera também em listas
encadeadas. Em geral, os processos são separados em lista de espera associadas a cada
tipo de evento. Neste caso, quando um evento acontece, todos os processos da lista
associada ao evento são transferidos para o estado de pronto.

Mudanças de Estado do Processo

Um processo muda de estado durante seu processamento em função de eventos


originados por ele próprios (eventos voluntários) ou pelo sistema operacional (ventos
involuntários). Basicamente, existem quatro mudanças de estado que podem acorrer a
um processo:

Pronto  Execução
Execução  Espera
Espera  Pronto
Execução  Pronto

Pronto  Execução – Após a criação de um processo, o sistema o coloca em uma lista


de processos no estado de pronto, onde aguarda por uma oportunidade para ser
executado. Cada sistema operacional tem seus próprios critérios e algoritmos para
escolha da ordem em que os processos serão executados (política de escalonamento).
Execução  Espera - Um processo em execução para o estado de espera por eventos
gerados pelo próprio processo, como uma operação de E/S, ou por eventos externos.
Um evento externo é gerado, por exemplo, quando o sistema operacional suspende por
um período de tempo a execução de um processo.

Espera  Pronto – Um processo no estado de espera passa para o estado de pronto


quando a operação solicitada é atendida ou o recurso esperado é concedido. Um
processo no estado de espera sempre terá de passar pelo estado de pronto antes de poder
ser novamente selecionado para execução. Não existe a mudança do estado de espera
para o estado de execução diretamente.

Execução  Pronto - Um processo em execução passa para o estado de pronto por


eventos gerados pelo sistema, como o término da fatia de tempo que o processo possui
para sua execução. Neste caso o processo volta para a fila de pronto, onde aguarda por
uma nova oportunidade para continuar seu processamento.

Um processo em estado de pronto ou de espera pode não se encontrar na memória


principal. Esta condição ocorre quando não existe espaço suficiente para todos os
processos na memória principal e parte do contexto do processo é levada para a
memória secundária. Uma técnica conhecida como swapping retira processos da
memória principal e os traz de volta seguindo critérios de cada sistema operacional.
Neste caso, os processos em estados de espera e pronto podem estar residentes ou não
residentes na memória principal.
Sub-processos:
Um processo pode criar outros processos e que podem, por sua vez, criarem tambem
outros processos de maneira hierárquica. Quando um processo (Processo pai) cria um
outro processo, a este chamamos de subprocesso ou processo filho, e este subprocesso
poderá criar subprocessos que podem criar outros subprocessos etc... gerando uma
arvore hierárquica de processos. Este tipo de recurso evita que o usuario tenha que
esperar que um processo termine para que sua requisiçao seja processada melhorando o
desempenho do sistema.

System Calls

É um mecanismo que protege o núcleo do sistema operacional intermediando as


chamadas dos aplicativos ao nucleo processando as solicitações e as respostas à estas
solicitações. Suas funções básicas são:

-Gerencia de processos.
- Gerência de memória.
- Gerência de Entrada e Saída..

5 Escalonamento de Processos
· Como memórias e terminais, a UCP é um recurso dividido para cada processo
no sistema.
· O escalonador é o componente do sistema operacional que determina qual
processo vai rodar num dado tempo e quanto tempo vai rodar.
· Sistema de partilha de tempo - permite que diversos processos funcionem
simultaneamente. Em um sistema monoprocessado cria uma ilusão de execução
simultânea, intercalando processos em uma base da partilha de tempo. O
escalonador entrega a CPU a cada processo por um pequeno período de tempo,
antes de trocar por outro processo. Este período é chamado de quantum do
tempo ou fatia do tempo.
· Dois aspectos do escalonador:
Política – As regras usadas para decidir qual
processo vai rodar e quando ele será trocado por outro.
Implementação – As estruturas de dados e algoritmos usados para cumprir tais políticas.
· Objetivos da política de escalonamento:
o Tempo de resposta rápido para aplicações interativas.
o Throughput elevado para trabalhos rodando em background.
o Execução da política eficientemente e com despesas gerais mínimas.

Escalonamento de Processos
Quando mais de um processo está ativo (pronto para executar) cabe ao
sistema operacional decidir qual terá a posse da CPU.
A parte do sistema operacional que toma esta decisão é chamada
escalonador e o algoritmo utilizado é o algoritmo de escalonamento.
Os critérios para os algoritmos de escalonamento são:
Processo: garantir que cada processo tenha acesso a CPU;
Eficiência: maximizar a utilização do processador, mantendo a CPU ocupada
praticamente 100% do tempo;
Tempo de resposta: minimizar o tempo de resposta na execução dos
processos principalmente os interativos editores planilhas etc;
tempo de espera: minimizar o tempo de espera de serviços não interativos
compilação impressão etc;
vazão: maximizar o numero de processos executados por
hora.
É importante observar que alguns desses objetivos são contraditórios como
por exemplo, se um algoritmo favorece os processos interativos estará
comprometendo os não interativos.

Tipos de escalonamento:
· não-preemptivo: processo que está executando não pode ser interrompido. Presente
nos primeiros
sistemas multiprogramáveis, onde predominava o processamento em batch. As políticas
que
implementam escalonamento não-preemptivo não são aplicáveis à sistemas de tempo
compartilhado,
pois em processos interativos é necessário um tempo de resposta ao usuário razoável.
· preemptivo: o processador pode ser retirado do processo que está executando. Permite
atenção
imediata aos processos mais prioritários (tempo real), melhores tempos de resposta
(tempo
compartilhado), compartilhamento uniforme do processador.
Algoritmos de escalonamento:
1.1 - Escalonamento Round Robin
Todos os processos tem a mesma importância.
Este e o mais antigo e simples algoritmo de escalonamento Cada
processo e executado por um intervalo de tempo quantum.
Algoritmos com Prioridades
Adequado para tratamento de situações de emergência
Múltiplas Filas
Este e um algoritmo que define classes com prioridades.
Tarefas Pequenas Primeiro
Este algoritmo e designado para aplicações não interativas onde o
tempo médio de execução é conhecido anteriormente.
Algoritmo PolicyDriven
Este algoritmo particiona a CPU de forma igual entre os usuários não entre
os processos.

THREADS: Um processo tem duas partes, ativa (fluxo de controle) e passiva


(espaço de endereçamento), uma thread consiste somente do fluxo de controle, é
chamada também de processo leve. É muito mais fácil e rápido criar uma thread que
processos, muitas vezes os processos usam dados compartilhados, e usar várias threads
no mesmo espaço de endereçamento é mais eficiente e mais rápido.
Sendo uma linha de execução a thread pode dividir a si mesma em duas ou mais tarefas
que podem ser executadas simultaneamente. O suporte técnico é fornecido pelo próprio
sistema operacional (SO), Uma thread permite que o usuário de um programa, por
exemplo, utilize uma funcionalidade do ambiente enquanto outras threads realizam
outros cálculos e operações.
thread ou processo peso leve (lightweight process): é a unidade de despacho
processo ou tarefa: é a unidade de alocação de recursos

Exemplo de uma thread, duas seções de copia de arquivos no Explorer são iniciadas
simultaneamente. Isto somente é possível porque cada seção corresponde a uma thread.

Benefícios de threads:

l É mais rápido criar uma thread que um processo


l É mais rápido terminar uma thread que um processo
l É mais rápido chavear entre threads de um mesmo processo
l Threads podem se comunicar sem invocar o núcleo já que compartilham
memória e arquivos

Contudo;
l Suspender um processo implica em suspender todas as threads deste processo já
que compartilham o mesmo espaço de endereçamento
l O término de um processo implica no término de todas as threads desse
processo

COMUNICAÇÃO ENTRE PROCESSOS

É comum processos trabalharem concorrendo e compartilhando recursos do sistema,


como arquivos, registros, dispositivos e áreas de memória. Na verdade o importante é
como estes processos irão usar e o que irão fazer com estes recursos. Um recurso mal
usado ou usado indevidamente pode comprometer o sistema ou o próprio processo
gerando falhas como podemos ver abaixo:

Um dos exemplos é de dois processos concorrentes que trocam informações através de


operação de gravação e leitura em um Buffer. Um processo só poderá gravar dados no
Buffer caso ele não esteja cheio, da mesma forma, um processo só poderá ler dados
armazenados no Buffer se existir algum dado a ser lido.

Para gerenciar este compartilhamento de forma que dois ou mais processos tenham
acesso a um mesmo recurso compartilhado, existe um mecanismo que controla este
acesso, chamado de MECANISMO DE SINCRONIZAÇÃO. Este mecanismo tem o
propósito de garantir a confiabilidade e a integridade da gravação dos dados, evitando
que os dados armazenados fiquem sem consistência. Como exemplo dois processos
efetuando operações de gravação, de dados diferentes, em disco exatamente no mesmo
setor ou no mesmo arquivo. Esta situação se torna mais crítica ainda em sistemas
operacionais MULTIPROGRAMÁVEIS.

Semáforos
Os semáforos fornecem um método de sincronização de acesso à recursos
compartilháveis entre múltiplos processos. Eles podem funcionar como locks(5) para
garantir acesso exclusivo ou como um contador, controlando o acesso a um número
finito de recursos. Quando um processo requisita um recurso, o contador é
decrementado, quando o recurso for liberado o contador é incrementado. Deste modo,
quando o semáforo indicar valor zero o processo solicitante bloqueia até que o recurso
seja liberado.

5. Locks: do inglês: travas

Há ocasiões onde é extremamente necessário que dois ou mais processos/threads


acessem um único recurso comum. Caso esse tipo de paralelismo não ocorra de forma
controlada, podemos fazer com que um processo "sequestre/atropele" a operação de
outro.
É ai que entram nossos sinalizadores, vulgo semáforos. Com eles, é possível acesso
controlado a processos, de forma que só haverá disponibilidade quando a operação em
andamento for finalizada.

Esse semáforos funcionam como indicadores (flags) que sinalizam para o ambiente se o
mesmo está ou não em utilização (os métodos de sinalização não são pertinentes ao
artigo, mas podemos didaticamente imaginar que pode ser 0 e 1, respectivamente 0 para
indisponível e 1 para disponível). Assim, o processo de sinalização requer colaboração e
troca de informações entre processos.

Semáforos:

O semáforo é uma variável que fica associada a um recurso compartilhado, indicando


quando este está sendo acessado por um outro processo. Ela terá seu valor alterado
quando o processo entra e quando sai da região crítica de forma que se um outro
processo entrar em sua região critica ele possa checar antes este valor para saber se o
recurso esta ou não disponível. Quando o processo tiver seu acesso impedido, ele será
colocado em uma fila de espera associada ao semáforo aguardando sua vez de utilizar o
recurso. Todos os processos da fila terão acesso ao recurso na ordem de chegada. O
semáforo pode ser usado também para implementar sincronizações condicionais. Isto
consiste em um processo que necessita ser notificado sobre a ocorrência de um evento.
Pode-se usar o semáforo para notificar este processo sobre a ocorrência deste evento.

Outro tipo de semáforo usado é SEMÁFORO CONSUMIDOR onde ele pode informar
ao processo se o buffer está cheio ou está vazio

SEMÁFORO CONTADOR é aquele que notifica os processos sobre o uso dos recursos.
Sempre que um processo usa um recurso qualquer, este semáforo é incrementado
sempre que um processo liberar um recurso ele será decrementado. Este semáforo é útil
para evitar que um processo na região crítica sem que hajam recursos disponíveis no
sistema.

O uso de semáforos exige do programador muito cuidado, pois qualquer engano pode
gerar bugs em seu programa que o levem a falhas de sincronização ocasionando quedas
e travamento geral do sistema.

Monitores:

São mecanismos de sincronização compostos de um conjunto de procedimentos,


variáveis e estrutura de dados definidos dentro de um módulo cuja finalidade é a
implementação automática da exclusão mútua entre seus procedimentos. Somente um
processo pode estar executando um dos procedimentos do monitor em um determinado
instante. Toda vez que um processo chamar um destes procedimentos, o monitor
verifica se já existe outro processo executando algum procedimento do monitor. Caso
exista, o processo fica aguardando a sua vez ate que tenha permissão para executa-lo.

A implementação da exclusão mútua nos monitores é realizada pelo compilador do


programa e não mais pelo programador. Para isto ele irá colocar todas as regiões críticas
do programa em forma de procedimentos no monitor e o compilador se encarregará de
garantir a exclusão mútua destes procedimentos. A comunicação do processo com o
monitor passa a ser feita através de chamadas a seus procedimentos e dos parâmetros
passados para eles.

Outra característica do monitor é que os processos, quando não puderem acessar estes
procedimentos, ficarão aguardando em uma fila de espera e enquanto isto, eles poderão
executar outros procedimentos.
Como ele é escrito em uma linguagem de programação, o compilador das outras demais
linguagens deverão ser capazes de reconhecê-la e implementa-la. São raras as
linguagens que permitem tal implementação criando uma limitação para o uso deste
recurso.

DEADLOCK

O Deadlock existe em qualquer sistema multiprogramável. Dizemos que um processo


está em Deadlock quando este para de responder porque está esperando por um evento
que nunca ocorrerá. Esta situação é conseqüência do problema da exclusão mútua.
Existem as condições onde o Deadlock irá ocorrer:

- Cada recurso só pode estar allocado a um único processo em um determinado instante.


(Exclusão mútua)

- Um processo além dos recursoss já alocados, pode estar esperando por outros recursos.

- Um recurso não pode ser liberrado de um processo porque outros processos desejam o
mesmo recurso (Não-preempção)

- Um processo pode ter de esperrar por um recurso alocado a outro processo e vice-
versa (Espera circular).

Prevenção do Deadlock:

Para prevenir o Deadlock é preciso garantir que uma das quatro condições acima citada
nunca ocorra, dentre as diversas situações já citadas pode ser feito um minucioso
trabalho de determinar muito bem que recursos, quais recursos e quando estes recursos
deverão ser disponibilizados aos processos.

Detecção do Deadlock:

Em sistemas que não possuam mecanismos que previnam a ocorrência de deadlocks, é


necessário um esquema de detecção e correção do problema. A Detecção do Deadlock é
um mecanismo que determina a existência deste e identifica os recursos envolvidos no
problema. Um Exemplo deste tipo de detector é o próprio Gerenciador de tarefas do
Windows que detecta o aplicativo que parou de responder ao sistema causado,
possivelmente, por um deadlock, como podemos ver logo abaixo:

Correção do Deadlock:

Geralmente o problema é resolvido eliminando os processos envolvidos e desalojando


os recursos para ele já garantidos. É aquele processo em que você dá um Alt+Cr+Del no
Windows e aparece uma janela informando o aplicativo que não responde. Este
aplicativo pode estar em um processo de Deadlock, neste caso você manda finalizar o
aplicativo e tudo voltará ao normal. Muitas vezes este mecanismo não resolve e pelo
contrário gera novos problemas. Se você finalizar um processo que esteja intimamente
envolvido com o sistema operacional ou que esteja usando recursos de baixo nível do
mesmo, você poderá vir a deixa-lo instável ou travado.

Abaixo vemos a caixa de dialogo do Windows que tentará fechar o processo que pode
estar parado por falta de comunicação com o sistema.

O problema do Deadlock é um problema que tende a tornar-se mais critico à medida


que os sistemas operacionais evoluem no sentido de implementar o paralelismo e
permitir a alocação dinâmica de um numero maior de recursos e a execução de um
numero maior de processos simultaneamente. Os usuários sentem muita saudade dos
computadores que rodavam o DOS nos bons tempos quando quase não davam
problemas. Mas é bom lembrar que o DOS era um sistema operacional monotarefa e
monousuário onde praticamente tínhamos apenas um único processo rodando de cada
vez. Neste caso não existiam os problemas que um ambiente multitarefa e multiusuário
tem hoje. Todos os recursos do sistema estavam exclusivamente disponíveis para aquele
processo e, portanto ele tinha total e plena liberdade de fazer com estes o que bem
entendia. Hoje os sistemas operacionais são mais complexos rodando em maquinas
mais críticas devido à velocidade de processamento tendo um maior numero de
aplicações que rodam simultaneamente e demandando praticamente todos os recursos
do sistema ao mesmo tempo. Muitos destes programas trabalham não só com um, mas
com vários processos simultaneamente o que aumentam as chances de colisões entre
eles ou com os recursos do sistema.

Conclusão:

Вам также может понравиться