Semana 3: Gerenciamento de Processos

Autor: Carlos Fernandes
E-mail para contato: carlos.fernandes@afogados.ifpe.edu.br

Objetivo da Aula:
Entender a criação, escalonamento, sincronização e terminação de processos nos sistemas operacionais modernos, com ênfase em Windows e Linux.

---

Introdução

Os processos são programas em execução e representam um dos conceitos fundamentais para a gestão de recursos nos sistemas operacionais. Esta aula abordará o ciclo de vida dos processos, diferentes técnicas de escalonamento, comunicação entre processos (IPC) e a implementação de threads para multiprocessamento.

---

1. O Que é um Processo?

Um processo é uma instância de um programa em execução, incluindo código, dados e informações de execução. Ele representa a unidade fundamental de execução dentro de um sistema operacional e desempenha um papel essencial no gerenciamento dos recursos do computador. Cada processo é isolado e gerenciado pelo sistema operacional, garantindo que operações independentes não interfiram umas nas outras.

Componentes de um Processo

Cada processo no sistema operacional possui:

• PID (Process Identifier): Identificador único atribuído pelo sistema operacional para controle e gestão.
• Espaço de Endereçamento: Memória dedicada ao processo, incluindo código, pilha e heap.
• Estado do Processo: Indica se o processo está em execução, pronto, bloqueado ou finalizado.
• Recursos Alocados: CPU, memória RAM, dispositivos de entrada/saída.

Estados de um Processo

Os processos podem estar em diferentes estados durante sua existência:

1. Novo: O processo foi criado e está aguardando alocação de recursos.
2. Pronto: O processo está apto a ser executado, aguardando pela CPU.
3. Executando: O processo está atualmente em execução na CPU.
4. Bloqueado: O processo aguarda um evento externo (como entrada do usuário ou leitura de disco).
5. Finalizado: O processo foi concluído e seus recursos foram liberados.

Exemplo no Dia a Dia de um Técnico de Manutenção

Um técnico de suporte pode frequentemente precisar monitorar processos para diagnosticar problemas de desempenho. Se um cliente relata que o computador está lento, o técnico pode usar o Gerenciador de Tarefas no Windows (Ctrl + Shift + Esc) para identificar processos que estão consumindo recursos excessivos. No Linux, comandos como ps aux, top e htop oferecem uma visão detalhada do uso da CPU e memória por cada processo.

Exemplo real: Um técnico detecta que o Antimalware Service Executable no Windows está consumindo muita CPU e orienta o cliente a configurar exceções para reduzir o impacto no desempenho.

Importância do Gerenciamento de Processos

O gerenciamento eficiente de processos impacta diretamente no desempenho e estabilidade do sistema. Alguns aspectos críticos incluem:

• Encerramento forçado de processos travados: No Windows, pode ser feito pelo taskkill /PID <número do processo> /F. No Linux, pode-se usar kill -9 <PID>.
• Ajuste de prioridades: No Windows, pode-se definir a prioridade de um processo pelo Gerenciador de Tarefas. No Linux, nice e renice ajustam a prioridade de um processo em execução.

Recursos e Referências

• Livro: “Operating System Concepts” – Abraham Silberschatz.
• Curso: “Fundamentos de Sistemas Operacionais” – Coursera.
• Artigos: “Como funcionam os processos no Windows e Linux” – IBM Developer.
• Vídeo: “Monitorando processos no Windows e Linux” – YouTube.

Atividade Prática

1. Utilize o Gerenciador de Tarefas do Windows para identificar processos que utilizam mais CPU.
2. No Linux, execute top e liste três processos que mais consomem recursos.
3. Pesquise sobre PID e Espaço de Endereçamento e explique sua relevância em um ambiente multitarefa.

Conclusão

Compreender os processos é essencial para diagnosticar problemas de desempenho e otimizar o uso dos recursos do sistema. Um profissional de suporte deve dominar ferramentas de monitoramento e gerenciamento de processos para solucionar questões comuns em ambientes Windows e Linux.

---

2. Estados de um Processo

Os processos podem estar em diferentes estados ao longo de sua execução. O sistema operacional gerencia esses estados dinamicamente, garantindo que os recursos sejam distribuídos de maneira eficiente. Os principais estados de um processo são:

2.1 Novo

Quando um programa é iniciado, ele entra no estado novo. Nesse momento, o sistema operacional aloca os recursos iniciais necessários e adiciona o processo à fila de processos prontos para execução.

Exemplo: Quando o usuário abre o Microsoft Word, o sistema operacional cria um novo processo para esse programa e prepara-o para execução.

2.2 Pronto

Neste estado, o processo está aguardando que a CPU esteja disponível para executá-lo. Ele possui todos os recursos necessários, exceto tempo de processamento da CPU.

Exemplo: No Windows, podemos observar processos prontos através do Gerenciador de Tarefas. No Linux, o comando ps -r exibe processos nesse estado.

2.3 Executando

Um processo entra no estado de execução quando a CPU está ativamente processando suas instruções. Apenas um processo pode estar nesse estado em um sistema de CPU única por vez, enquanto em sistemas multiprocessados, vários processos podem ser executados simultaneamente.

Exemplo: Quando o usuário digita em um editor de texto ou executa um vídeo, os processos associados a essas tarefas estão em execução.

2.4 Bloqueado

O processo entra nesse estado quando precisa aguardar um evento externo, como a finalização de uma operação de entrada/saída (E/S) ou a disponibilidade de um recurso.

Exemplo: Quando um programa está esperando por entrada do teclado ou leitura de um arquivo do disco rígido, ele fica bloqueado até que a operação seja concluída.

2.5 Finalizado

Quando um processo conclui sua execução ou é encerrado pelo sistema operacional ou pelo usuário, ele entra no estado de finalizado. Seus recursos são liberados e removidos da tabela de processos.

Exemplo: Se um programa é fechado pelo usuário, o processo correspondente é finalizado e removido da memória.

---

Importância do Gerenciamento de Estados

A transição entre estados é essencial para a eficiência do sistema operacional. Algumas ferramentas utilizadas para monitorar estados de processos incluem:

• Windows: Gerenciador de Tarefas (Ctrl + Shift + Esc) e tasklist via Prompt de Comando.
• Linux: top, htop e ps para visualizar processos ativos e seus estados.

---

Recursos e Referências

• Livro: “Operating System Concepts” – Abraham Silberschatz.
• Curso: “Fundamentos de Sistemas Operacionais” – Coursera.
• Artigos: “Como funcionam os processos no Windows e Linux” – IBM Developer.
• Vídeo: “Monitorando processos no Windows e Linux” – YouTube.

---

Atividade Prática

1. Utilize o Gerenciador de Tarefas do Windows para identificar processos em diferentes estados.
2. No Linux, execute ps -aux e classifique os processos observados em pronto, executando e bloqueado.
3. Pesquise e explique como o sistema operacional decide qual processo deve ser executado a seguir.

---

Conclusão

Os estados de um processo representam fases fundamentais na gestão de execução de programas dentro de um sistema operacional. O entendimento desses conceitos é essencial para técnicos de suporte e profissionais de TI que precisam diagnosticar e otimizar o desempenho do sistema operacional.

---

3. Escalonadores de Processos

O escalonamento gerencia a alocação da CPU entre processos, garantindo que os recursos do sistema sejam utilizados de forma eficiente e que os programas sejam executados conforme suas necessidades. O escalonador do sistema operacional decide qual processo deve ser executado em determinado momento, influenciando diretamente o desempenho e a responsividade do sistema.

Tipos de Escalonamento

Os principais tipos de escalonamento de processos incluem:

1. FIFO (First In, First Out)

   • Os processos são executados na ordem em que chegam.
   • Simples de implementar, mas pode levar a tempos de resposta elevados para processos mais longos.
   • Exemplo: Se três programas forem abertos sequencialmente, o primeiro será executado até a conclusão antes que o segundo inicie.

2. Round Robin

   • Cada processo recebe um tempo limite (“quantum”) para execução antes de ser suspenso e dar lugar ao próximo.
   • Equilibra a distribuição de CPU entre vários processos, evitando que um único programa monopolize o sistema.
   • Exemplo: No Windows, vários aplicativos abertos simultaneamente compartilham a CPU, alternando rapidamente entre si.

3. Prioridade

   • Cada processo recebe uma prioridade, e aqueles com maior prioridade são executados primeiro.
   • Pode ser preemptivo (um processo de menor prioridade pode ser interrompido por um mais prioritário) ou não preemptivo (um processo só libera a CPU ao terminar).
   • Exemplo: No Windows, é possível definir a prioridade de um processo pelo Gerenciador de Tarefas (Ctrl + Shift + Esc), clicando com o botão direito sobre um processo e ajustando a prioridade.

Importância do Escalonamento

O escalonamento impacta diretamente a responsividade do sistema e a eficiência no uso dos recursos. Sistemas operacionais modernos, como Windows e Linux, implementam técnicas avançadas de escalonamento para otimizar o desempenho e minimizar tempos de espera.

Ferramentas para Monitoramento

• Windows: O Gerenciador de Tarefas permite visualizar e modificar a prioridade dos processos em execução.
• Linux: O comando top exibe informações sobre o uso da CPU por cada processo, e nice permite ajustar a prioridade manualmente.

Recursos e Referências

• Livro: “Operating System Concepts” – Abraham Silberschatz.
• Curso: “Fundamentos de Sistemas Operacionais” – Coursera.
• Vídeo: “Como funciona o escalonamento de processos?” – YouTube.

Atividade Prática

1. Utilize o Gerenciador de Tarefas do Windows para modificar a prioridade de um processo e observe o impacto no desempenho.
2. No Linux, execute top e identifique os processos com maior tempo de CPU.
3. Pesquise sobre o impacto de diferentes algoritmos de escalonamento na execução de tarefas críticas.

---

Conclusão

O escalonamento de processos é um aspecto essencial do funcionamento dos sistemas operacionais, influenciando diretamente a performance e eficiência na execução de tarefas. Compreender como os processos são alocados e gerenciados é fundamental para técnicos de suporte que lidam com otimização de sistemas e solução de problemas de desempenho.

---

4.Comunicação entre Processos (IPC) em Sistemas Operacionais

A comunicação entre processos (“Inter-Process Communication” – IPC) é um conjunto de mecanismos que permite que diferentes processos troquem informações e coordenem suas execuções. Em sistemas operacionais modernos, a IPC é essencial para garantir a cooperação entre aplicações e a otimização do uso de recursos computacionais. Neste conteúdo, abordaremos os principais métodos de IPC utilizados no Windows e no Linux, com exemplos práticos e referências para estudo adicional.

---

1. Pipes – Conexão entre Processos

Os pipes (“tubulações”) permitem a transmissão unidirecional ou bidirecional de dados entre processos. Eles podem ser classificados em:

• Pipes anônimos: Criados por um processo e utilizados para comunicação com processos filhos. No Windows, são implementados por meio da API CreatePipe(), enquanto no Linux utiliza-se comandos como pipe().
• Named Pipes (Pipes Nomeados): Permitem comunicação entre processos independentes. No Windows, são implementados através da API CreateNamedPipe(). No Linux, são acessíveis via mkfifo e manipulados como arquivos comuns.

Exemplo no Windows (Named Pipe em Python):

import win32pipe, win32file
pipe = win32pipe.CreateNamedPipe(
    r'\\.\pipe\MeuPipe',
    win32pipe.PIPE_ACCESS_DUPLEX,
    win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT,
    1, 65536, 65536, 0, None)

Exemplo no Linux (Criando um Named Pipe e Escrevendo Dados):

mkfifo /tmp/meu_pipe
echo "Mensagem para outro processo" > /tmp/meu_pipe

2. Sockets – Comunicação em Rede

Os sockets permitem a comunicação entre processos em diferentes máquinas ou dentro do mesmo sistema. Eles são fundamentais para aplicações que utilizam redes, como servidores web e clientes de banco de dados.

Tipos de Sockets:

• Sockets TCP: Conexão orientada que garante entrega confiável de dados.
• Sockets UDP: Mais rápido, mas sem garantia de entrega.

Exemplo de Servidor de Socket em Python (Windows/Linux):

import socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 65432))
server.listen()
print("Aguardando conexão...")
conn, addr = server.accept()
print("Conectado a", addr)
conn.close()

3. Shared Memory – Memória Compartilhada

A memória compartilhada é uma forma eficiente de IPC, pois permite que múltiplos processos acessem diretamente uma área de memória comum. No Linux, isso é feito através da API System V (shmget, shmat, shmdt). No Windows, a API CreateFileMapping() e MapViewOfFile() são usadas.

Exemplo no Linux (Criando Memória Compartilhada com shmget):

int shmid = shmget(IPC_PRIVATE, 1024, IPC_CREAT | 0666);
char *shmaddr = shmat(shmid, NULL, 0);

Exemplo no Windows (Criando Memória Compartilhada com CreateFileMapping):

HANDLE hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 256, "MeuMapaDeMemoria");
LPVOID pBuf = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 256);

4. Mensagens – Envio e Recebimento de Dados

Os sistemas operacionais também oferecem mecanismos para troca de mensagens entre processos. No Windows, a API PostMessage() e SendMessage() são amplamente usadas. No Linux, a comunicação por mensagens pode ser feita através de msgget().

Exemplo no Linux (Fila de Mensagens com msgget()):

key_t key = ftok("arquivo", 'B');
int msgid = msgget(key, 0666 | IPC_CREAT);

Exemplo no Windows (Enviando Mensagem entre Janelas com SendMessage()):

SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM)L"Nova Mensagem");

---

Conclusão

A comunicação entre processos é um conceito essencial para o funcionamento eficiente de sistemas operacionais modernos. Cada método possui suas vantagens e desvantagens dependendo do contexto de uso. O aprendizado e a prática desses mecanismos são fundamentais para profissionais que trabalham com manutenção e suporte em TI.

Referências para Estudo

• Livros:

  • Tanenbaum, A. S. (2014). “Modern Operating Systems”.
  • Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). “Operating System Concepts”.

• Cursos Online:

  • “Fundamentos de Sistemas Operacionais” – Coursera
  • “Linux System Programming” – Udemy

• Sites e Documentações:

  • Microsoft Docs – Named Pipes
  • Linux Programmer’s Manual
  • The Linux Documentation Project

• Vídeos:

  • “Introduction to IPC Mechanisms” – YouTube, canal Gynvael Coldwind.
  • “Linux Shared Memory IPC” – The Linux Foundation.

---

5.Threads e Multithreading

Introdução

Threads são subunidades de um processo que permitem a execução concorrente dentro do mesmo espaço de memória. Elas são fundamentais para melhorar a eficiência dos sistemas operacionais modernos, permitindo a execução de múltiplas tarefas simultaneamente. Em sistemas de múltiplos núcleos, as threads possibilitam um melhor aproveitamento da CPU, reduzindo o tempo de resposta de aplicativos e garantindo uma comunicação eficiente entre processos.

Conceito de Thread e Multithreading

Uma thread pode ser vista como um fluxo de execução dentro de um processo. Enquanto um processo pode conter múltiplas threads, todas compartilham o mesmo espaço de memória e recursos do processo principal.

Diferenças entre Processos e Threads

• Processos possuem seu próprio espaço de memória e recursos alocados pelo sistema operacional.
• Threads compartilham o mesmo espaço de memória e recursos de um processo.
• Criação e troca de contexto de processos são mais custosas do que de threads.
• Threads comunicam-se de maneira mais eficiente do que processos independentes.

Implementação de Threads no Windows

No Windows, o sistema fornece suporte a threads por meio da API de Windows Threads. A função CreateThread é usada para criar uma nova thread dentro de um processo:

#include <windows.h>
#include <stdio.h>

DWORD WINAPI MinhaThread(LPVOID lpParameter) {
    printf("Thread em execução!\n");
    return 0;
}

int main() {
    HANDLE hThread;
    DWORD threadID;

    hThread = CreateThread(
        NULL,        // Atributos padrão
        0,           // Tamanho do stack padrão
        MinhaThread, // Função executada pela thread
        NULL,        // Argumento passado
        0,           // Flags
        &threadID    // Identificador da thread
    );

    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);

    return 0;
}

Este código cria uma thread no Windows que executa a função MinhaThread e imprime uma mensagem no console.

Implementação de Threads no Linux

No Linux, a biblioteca pthread fornece suporte a threads. O código abaixo demonstra a criação de uma thread usando pthread_create:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void* MinhaThread(void* arg) {
    printf("Thread em execução!\n");
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, MinhaThread, NULL);
    pthread_join(thread, NULL);
    return 0;
}

Este código cria uma thread no Linux utilizando pthread_create, executando a função MinhaThread.

Vantagens do Multithreading

1. Melhor aproveitamento da CPU – O sistema pode executar múltiplas tarefas simultaneamente.
2. Menor tempo de resposta – Melhor desempenho em aplicações que exigem múltiplas operações concorrentes.
3. Melhor comunicação – Threads compartilham o mesmo espaço de memória, reduzindo a necessidade de mecanismos complexos de IPC (Interprocess Communication).

Ferramentas para Monitoramento de Threads

• Windows: O Gerenciador de Tarefas exibe os processos e suas threads associadas. O comando tasklist /v no Prompt de Comando exibe detalhes das threads.
• Linux: O comando htop exibe informações detalhadas sobre processos e threads em execução. Outra opção é o comando ps -eLf.

Material Complementar

• Slides: Estados de processos e modelos de escalonamento.
• Vídeo: Demonstração de escalonamento no Windows e Linux.
• Livros:
  • Operating System Concepts – Abraham Silberschatz
  • Modern Operating Systems – Andrew S. Tanenbaum
• Cursos Gratuitos:
  • “Fundamentos de Sistemas Operacionais” – Coursera
  • “Introdução ao Linux” – Linux Foundation

Atividades Práticas

1. No Windows, abra o Gerenciador de Tarefas e identifique três processos críticos do sistema.
2. No Linux, execute ps -ef e identifique processos ativos.
3. Pesquise sobre IPC (Interprocess Communication) e compartilhe exemplos de implementação nos fóruns avaliativos.

Conclusão

Compreender threads e multithreading é essencial para a otimização de sistemas operacionais e o desenvolvimento de aplicações eficientes. O uso adequado de threads permite melhor aproveitamento de recursos computacionais e melhor tempo de resposta de sistemas modernos.

Fim da Aula 03