Processo (informática)

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
NoFonti.svg
Esta página ou secção cita fontes confiáveis e independentes, mas que não cobrem todo o conteúdo (desde maio de 2010). Por favor, adicione mais referências e insira-as corretamente no texto ou no rodapé. Material sem fontes poderá ser removido.
Encontre fontes: Google (notícias, livros e acadêmico)
Processo, no contexto da informática, é um programa de computador em execução.

Em sistemas operacionais, processo é um módulo executável único, que corre concorrentemente com outros módulos executáveis. Por exemplo, em um ambiente multi-tarefa (como o Unix) que suporta processos, um processador de texto, um navegador e um sistema de banco de dados são processos separados que podem rodar concomitantemente. Processos são módulos separados e carregáveis, ao contrário de threads, que não podem ser carregadas. Múltiplas threads de execução podem ocorrer dentro de um mesmo processo. Além das threads, o processo também inclui certos recursos, como arquivos e alocações dinâmicas de memória e espaços de endereçamento.

A comunicação entre processos é o grupo de mecanismos que permite aos processos transferirem informação entre si. A capacidade de um sistema operacional executar simultaneamente dois ou mais processos é chamada multiprocessamento. Se existirem dois ou mais processos executados em simultâneo e disputam o acesso a recursos partilhados, problemas da concorrência podem ocorrer. Estes problemas podem ser resolvidos pelo gerenciamento adequado de múltiplas linhas de execução ou processos através da sincronização (multitarefa) ou por outros recursos (como a troca de contexto).

A execução de um processo ocorre de maneira sequencial, ou seja, uma instrução após a outra. A qualquer instante, apenas uma instrução de um determinado processo é executada. Os processos também exercem a atividade de executar operações concorrentes mesmo que possua apenas uma Unidade Central de Processamento disponível.

Embora dois processos possam estar associados a um mesmo programa, são considerados duas sequências de execução distintas. Por exemplo, cópias de um programa de correio eletrônico podem estar sendo executadas por vários usuários ou o mesmo usuário pode estar usando diversas cópias de um processador de texto. Cada um desses programas em execução constitui um processo distinto e, por mais que o texto de alguns programas possa ser o mesmo, o estado de cada um será diferente. É comum ter um processo que crie muitos processos durante sua execução, criando uma hierarquia entre processos pais e filhos. 

Tipos de Processo[editar | editar código-fonte]

Dentre os processos, podemos destacar dois principais tipos que estão relacionados a seu local de execução, no caso CPU e Entrada e Saída de dados.

  • Processos CPU bound (orientados à CPU): são processos que utilizam muito o processador, em que o tempo de execução é definido pelos ciclos de processador.
  • Processos I/O bound (orientados à E/S): são processos que realizam muitas operações de entrada e saída de dados, em que o tempo de execução é definido pela duração destas. 
  • IDEAL: existir um balanceamento entre processos CPU-bound e I/O-bound; 

Representação[editar | editar código-fonte]

Em geral, processos de sistemas computacionais são formados pelos seguintes recursos:

  • Uma imagem do código de máquina executável associado com um programa.
  • Memória, que inclui o código executável, dados específicos do processo (dados da entra e saída), uma chamada de pilha (para manter a pilha de subrotinas ativas e/ou outros eventos) e um heap (alocação dinâmica de memória) para manter a computação intermediária gerada durante o tempo de execução.
  • Descritores de sistema operacional que são alocados aos processo, como os descritores de arquivo do (segundo a terminologia UNIX) ou handles (usado no Windows) e os códigos e sinks.
  • Atributos de segurança, tais como conjunto de permissões para o usuário que criou o processo, são as operações permitidas.
  • Contexto de estado do processador, tal como o conteúdo dos registradores, memória física de endereçamento. O estado é normalmente guardado nos registradores quando o processo está em execução, e na memória principal caso contrário.

O sistema operacional mantém a maior parte da informação sobre processos dentro de estruturas de dados chamadas Bloco de controle de processos

Qualquer subconjunto de recursos, mas normalmente ao menos o estado do processador, pode ser associado com cada um dos processos threads no sistema operacional, que suporte threads ou processos 'filho'.

O sistema operacional mantém esses processos separados e aloca recursos necessários para cada um deles, diminuindo as chances de um processo atrapalhar o outro (e.g., deadlock). O sistema operacional pode além disso prover mecanismos para comunicação entre processos, permitindo assim interação e comportamento mais seguro entre os processos.

Memória compartilhada[editar | editar código-fonte]

Vantagens[editar | editar código-fonte]

  • Melhora o desempenho de processos que acessam frequentemente dados compartilhados.
  • Os processos podem compartilhar a mesma quantidade de dados que podem endereçar.

• Interface padronizada[editar | editar código-fonte]

  • Memória compartilhada System V
  • Memória compartilhada POSIX
  • Não permite que os processos mudem privilégios de um segmento de memória compartilhada.

Hierarquia de processos[editar | editar código-fonte]

Em alguns sistemas, quando um processo cria outro, o processo pai e o processo filho continuam, de certa forma, associados. Os processo filhos pode criar mais processos, formando assim uma hierarquia de processos, porém nela apenas existirá um processo pai e ter ou não um ou mais processos filhos.

Este tipo de organização dificulta a propagação de vírus em nossos sistemas operacionais, pois quando um processo pai é “morto” seja pelo sistema ou pelo próprio usuário, todos que estiverem abaixo dele na hierarquia serão mortos também.

No UNIX, um processo, todos os seus filhos e descendentes formam um grupo de processos. Exemplos da atuação de hierarquia ocorre quando há envio de sinal do teclado, onde o sinal é entregue a todos os processos associados ao teclado. Individualmente, cada processo pode capturar o sinal, ignorá-lo ou tomar a ação predefinida, isto é, ser finalizado pelo sinal. Além disso, os processos filhos não podem ser deserdados do processo pai.

Por outro lado, o Windows não apresenta esse conceito de hierarquia, nele todos os processos são iguais. Algo parecido com uma hierarquia ocorre somente quando um processo é criado. Ao pai é dado um identificador especial, que ele ode usar para controlar o filho. Contudo, ele é livre para passar o identificador para alguns outros processos, invalidando, assim, a hierarquia.

Estados de processos[editar | editar código-fonte]

Estados possíveis para um processo, e seus relacionamentos entre si.

Não-Submetido[editar | editar código-fonte]

É o processo que ainda não está submetido a CPU, está nas mãos do usuário." Até onde interessa ao sistemas ele não existe, porque o usuário ainda não o submeteu. Ele é simplesmente apresentado como sendo o primeiro passo na vida de um processo. O Sistema Operacional, naturalmente, não reconhece esse estado.[1]". Pode por exemplo, ser um arquivo executável que está armazenado no HD.

Suspenso[editar | editar código-fonte]

É o processo que já foi submetido, porém permanece suspenso até que o horário ou evento programado ao usuário venha acontecer. Processo suspenso é aquele que esta no aguarde de uma entrada de dados.

Pronto[editar | editar código-fonte]

O processo já foi submetido e está pronto para receber a CPU, porém ainda aguarda o escalonador de processos para ter controle da CPU. Processos que estão esperando E/S não se aplicam a esse estado.

Executando[editar | editar código-fonte]

A execução propriamente dita. O código está sendo processado. Se ocorrer durante a execução uma requisição de E/S o processo é colocado no estado de espera e outro processo da fila de prontos poderá então concorrer a CPU.

Espera[editar | editar código-fonte]

É o processo que foi colocado na fila de espera de E/S devido ao processador de E/S ser mais lento que a CPU principal. O processo tornaria a CPU mais escrava dele se não houvesse esse estado, pois como ele não está concorrendo à CPU ao executar um E/S, pode-se então colocá-lo no estado de espera para que os demais processos do estado pronto possam concorrer a CPU.

Ex: parte de um código em C

  scanf(“%d”, &VALOR);
  SOMA=VALOR+JUROS;

Como podemos notar, a instrução scanf (uma requisição de entrada e saída) é gerada se não fosse possível colocar o processo em estado de espera; caso o usuário não entrasse com nenhum valor, o programa ficaria suspenso e não liberaria a CPU para outros processos.

Completo[editar | editar código-fonte]

Neste estado temos a finalização do processo.

Criação de Processos[editar | editar código-fonte]

Há várias razões para o início de um processo, os principais são:

  • Inicio do sistema;
  • Solicitação de chamada de execução ao sistema de criação de processo;
  • Solicitação do usuário;
  • Início de um job em lote.
  • Quando se cria um processo, o sistema operacional realiza os seguintes passos:
  • Atribui um identificador único ao processo. Cria-se o BCP, mas só se preenche o campo do identificador.
  • Atribui memória ao processo.
  • Inicializa o BCP.
  • Inserir o processo na lista de processos que corresponda. Por exemplo na lista de processos prontos.
  • Outras operações, como atualizar todas as estruturas de controle que mantenha o sistema operacional.

Término de Processos[editar | editar código-fonte]

Os processos podem terminar de forma voluntária e involuntária. Aqui estão alguns exemplos de motivos para os processos cessarem sua execução e sua forma:

  • Saída normal: A tarefa anteriormente solicitada já terminou sua execução (saída voluntária);
  • Saída por erro: O arquivo não é encontrado (saída voluntária);
  • Erro fatal: é efeituado uma divisão por 0 (saída involuntária);
  • Cancelamento por um outro processo: kill, TerminateProcess (saída involuntária).

Bloco de Controle de Processo (BCP)[editar | editar código-fonte]

BCP é a estrutura de dados que contém a informação a cerca de um processo se denomina bloco de controle de processos (BCP)

A manifestação de um processo em um sistema operacional é um BCP. Um BCP é a representação de um processo durante sua execução. Um BCP é criado quando se cria seu processo associado. O conjunto de BCPs representa o estado do sistema. São acedidos e mantidos por rotinas do sistema operacional.

Elementos do BCP
  • Informações importantes para o controle
  • identificação do processo, estado em que ele se encontra, prioridade.
  • registradores,r status
  • ponteiros: pilha, código e dados
  • tempos: início, de CPU, alarmes, dos filhos
  • diretórios: raiz, trabalho
  • descritores de arquivos

O BCP permite ao sistema operacional localizar toda a informação dos processos. O conjunto de BCP forma as tabelas de processos. O vão do processo usa-se como índice nas tabelas dos processos.

Localização dos processos[editar | editar código-fonte]

  • Processos ficam em estruturas que os classificam conforme seu estado. Processos Prontos à serem escalonados para a execução ficam na lista/fila de prontos.

Estados do processo em Linux[editar | editar código-fonte]

O linux trabalha com 4 estados de processo.

  • Executável: O processo pode ser executado imediatamente.
  • Dormente: Precisa aguardar algo para ser executado.
  • Parado: Não pode ser executado.
  • Zumbi: O processo é considerado "morto", mas ainda existe.

Alguns comandos que podem ser utilizados[editar | editar código-fonte]

  • Ps - Pelo comando ps é possível saber quais os processos em execução atualmente, quais os PIDs correspondentes e outros.
  • Kill - O comando Kill tem a função de "matar" um processo, e é usado em momentos críticos.
  • Jobs - Este comando visualiza os processos que estão parados ou executando em segundo plano.
  • Bg - Coloca a última tarefa que estiver em segundo plano em execução.

Fork no Unix[editar | editar código-fonte]

O fork no Unix cria um processo filho, que diferencia-se a partir do processo pai somente em suas PID e PPID. O fork consome tempo e memória requerida para duplicar as tabelas do processo pai. Se funcionar, a PID do processo filho é devolvido para o pai e retorna-se um 0 para o filho. Caso contrário, um -1 é retornado no contexto pai, e não se cria o processo filho.

Referências

  1. William Shay , "Sistemas Operacionais"(1996), São Paulo:Makron Books

Ver também[editar | editar código-fonte]

Ícone de esboço Este artigo sobre Informática é um esboço. Você pode ajudar a Wikipédia expandindo-o.