PROCESSOS E

THREADS

Aula 1

CONCEITOS DE PROCESSOS

Conceitos de processos
Olá, estudante! Nesta videoaula, conheceremos conceitos de
processos e multiprocessamento, multitarefas em sistemas
operacionais e o funcionamento do escalonamento de processos.

Esse conteúdo é importante para a sua prática profissional, pois

fornece as bases para o design, a gestão e a otimização de
sistemas modernos. Seja para criar aplicações performáticas, seja
para manter a operação estável de servidores e infraestruturas,
esses conceitos impactam diretamente a capacidade do
profissional de TI de entregar soluções eficientes e confiáveis.

Prepare-se para essa jornada de conhecimento! Vamos lá!

Ponto de Partida
Olá, estudante, boas-vindas!

Nesta unidade, exploraremos os conceitos de processos.

A arquitetura de um sistema operacional envolve uma série de

componentes e recursos que permitem a comunicação entre os
aplicativos em sua estrutura. Cada programa em execução
representa um processo, e podemos definir sua execução como
uma entidade que representa uma unidade básica a ser
implementada no sistema. Sempre que um programa é
executado, todas as instruções que foram desenvolvidas para
permitir a sua execução são lidas de forma sequencial, realizando
as operações e os escalonamentos.

Nesta aula, conheceremos os conceitos básicos sobre a definição

de um processo e qual a sua função em um sistema operacional,
compreendendo qual a importância do núcleo do sistema e das
definições sobre multiprocessamento, multitarefas e
multiprocessos.

Ao final, compreenderemos como os processos são úteis em um

sistema e descreveremos como ocorre o uso de recursos por
parte do sistema e dos programas executados pelos usuários.
Aprofundaremos nossa compreensão desses conceitos e
exploraremos como os conceitos de processos são fundamentais
em sistemas operacionais.

Bons estudos!

Vamos Começar!
Funções de um processo e
multiprocessamento
Nos primórdios da tecnologia, quando surgiram os primeiros
computadores, um único processador fazia parte da arquitetura
desses equipamentos, contendo uma Unidade Central de
Processamento (CPU) composta de um núcleo (kernel),
entregando com isso um menor desempenho quando
comparamos com as tecnologias atuais.

Todavia, um núcleo pode ser definido como um componente que

registra e executa instruções de armazenamento de dados,
enquanto a CPU é capaz de executar essas instruções, com um
único propósito: resposta por meio de aplicações e softwares,
como visto na Figura 1.

Figura 1 | Núcleo conectando aplicações. Fonte: adaptada de Wikiwand

(2025, [s. p.]).
Além dos processadores e do núcleo, o sistema operacional
trabalha com controladores de disco, teclados e gráficos, em que
cada um deles executa um número limitado de instruções e não
autuam com processos, sendo gerenciados a fim de enviar
informações para o núcleo sobre as próximas tarefas e monitorar
os status (Silberschatz; Gagne; Galvin, 2015; Tanenbaum;
Woodhull, 2008).

De forma adicional, o controlador de disco recebe uma sequência

de requisições do núcleo e controla a fila de solicitações, por meio
do agendamento de tarefas no disco. Com a evolução da
tecnologia, dificilmente um sistema operacional utiliza um único
processador ou núcleo. Sendo assim, computadores modernos,
dispositivos móveis a servidores, introduziram os sistemas
multiprocessadores.

Sistemas multiprocessadores são definidos pelo uso de dois (ou

mais) processadores, no qual cada um deles possui uma CPU de
núcleo único. Nesse caso, houve atualizações nos barramentos
(utilizados para permitir a conexão de componentes), os quais
permitem que os processadores compartilhem informações com
outros componentes, como a memória e os dispositivos
periféricos (Alves, 2014).

Com o surgimento dos sistemas multiprocessadores, como

vantagem, observou-se um aumento na taxa de transferência de
informações, permitindo que múltiplos trabalhos possam ser
realizados, consumindo um menor tempo do sistema. Entre os
sistemas multiprocessadores mais comuns, estão os que utilizam
o multiprocessamento simétrico (SMP). Nesse modo de operação,
cada processador da CPU realiza as tarefas de forma simultânea,
incluindo funções exercidas pelo sistema operacional e os
processos que são direcionados pelo usuário mediante um
conjunto próprio de registros e cache (ou seja, memória
temporária implementada para apoiar as tarefas, com acessos
mais rápidos ao conteúdo, com foco no desempenho das tarefas
(Silberschatz; Gagne; Galvin, 2015).

Apesar disso, alguns recursos são compartilhados entre os

processadores, como a memória física do barramento. Mesmo
assim, muitos processos podem ser executados por cada CPU ao
mesmo tempo. Ainda assim, existem algumas limitações como em
casos de falha, em que a inatividade de uma das CPUs pode
causar sobrecarga para as demais, causando problemas de
desempenho e influenciando negativamente nos resultados.

Assim como as demais funcionalidades, o conceito de

multiprocessador também evoluiu e, com o passar do tempo,
surgiram os sistemas multicore, nos quais vários núcleos de
computação residem em um chip único e podem agregar maior
eficiência pelo fato da agilidade que a comunicação entre chips
permite. Sobre as vantagens do multicore, Silva e Borges (2024)
afirmam que o uso de chips que utilizam vários núcleos influencia
significativamente no consumo de energia, em comparação com
os chips single-core, o que é importante para dispositivos móveis
e laptops, que consideram a autonomia da bateria um ponto
importante.

Praticamente todos os sistemas operacionais modernos –

incluindo Windows, Mac OS e Linux, bem como sistemas móveis
Android e iOS – suportam sistemas SMP multicore, e os sistemas
operacionais evoluem cada vez mais, visando ao melhor
aproveitamento de seus recursos.

Siga em Frente...
Multitarefas em sistemas operacionais
Quando falamos de um sistema com multiprocessamento,
devemos considerar outras características importantes, e uma
delas está diretamente relacionada com a multiprogramação, que
é quando há a capacidade de executar vários programas,
mantendo não somente a CPU, mas os dispositivos de E/S
ocupados em tempo integral.

A multiprogramação otimiza a utilização da CPU e permite que os

usuários possam realizar todas as suas tarefas. Para compreender
como isso funciona, imagine um sistema operacional sem
multiprogramação. Todo programa que esteja em execução é
denominado processo, e diversos processos podem ser
executados simultaneamente na memória. Sendo assim, o sistema
escolhe e executa os processos e, eventualmente, os demais
precisam esperar. Os processos em espera são denominados
tarefas, e a CPU fica inativa até que um processo seja finalizado
para o outro iniciar (Tanenbaum; Woodhull, 2008). Já em um
sistema multiprogramado isso não acontece, e vários processos
podem ser executados (Figura 2).
 Figura 2 | Sistema operacional
multitarefas e multiprocessos. Fonte:
elaborada pelo autor.

Se um usuário estivesse utilizando um processador de texto e

precisasse utilizar a agenda, o primeiro processo era bloqueado
até que o segundo pudesse ser executado. Ambos continuavam
existindo, mas somente um deles poderia ser acessado (Figura 3),
ou seja, os processos seguem sendo alternados. É aí que entra o
conceito de multitarefa. Uma tarefa é um conjunto de instruções,
e o termo multitarefa pode ser caracterizado como uma extensão
da multiprogramação, executada logicamente. Parece difícil
imaginar que um sistema monotarefa já tenha existido, porém,
nos primórdios da computação, apenas uma tarefa podia ser
executada por vez, até que o nível de paralelização de processos
que existe atualmente fosse alcançado.

Figura 3 | Sistema com um único núcleo. Fonte: elaborada pelo autor.

Pode haver uma certa confusão entre os termos apresentados até

aqui, mas basta pensar na multitarefa como a capacidade de um
sistema operacional de executar mais de uma tarefa ao mesmo
tempo (como o próprio nome diz) em uma máquina com
processador único, diferente do multiprocessamento, no qual mais
de uma CPU é utilizada. O tempo de resposta se torna mais
rápido, e os processos de E/S (entrada/saída) podem ser
interativos, enviados para o usuário por meio de recursos, como
mouse, teclado ou tela (Oliveira, 2015).
Um sistema multitarefas precisa lidar com a prioridade na
execução dos programas para que possa definir como os recursos
serão utilizados para atender ao que está sendo executado em
determinado momento. Se a capacidade de multitarefa do
sistema nota que um processo pode ser parcialmente
interrompido ou pausado para atender às necessidades de outro
processo, o estado do processo é salvo e outro iniciado,
intercalando a execução.

Finalmente, a execução de vários processos requer a limitação da

capacidade do sistema em influenciar em todos os seus estágios,
incluindo agendamento, armazenamento e gerenciamento de
memória. Em um sistema multitarefa, o sistema operacional deve
garantir um tempo de resposta razoável. A forma mais comum de
fazer isso é a memória virtual, que é uma tecnologia que permite
a execução de processos utilizando o disco (Tanenbaum;
Woodhull, 2008).

Um processo é um conjunto de recursos utilizados por uma ou

mais tarefas, e as tarefas fazem uso dos recursos por meio dos
processos. As tarefas de um mesmo processo costumam trocar
informações, e o núcleo do sistema é responsável por isolar os
contextos de execução de diversas tarefas.

Funcionamento do escalonamento de processos

O objetivo da multiprogramação é ter algum processo em

execução, o tempo todo, para maximizar a utilização da CPU, e daí
surge o conceito de escalonamento de processos, em que o
principal objetivo é compartilhar o tempo de execução do qual o
sistema disponibiliza e alternar as funções do núcleo da CPU
entre os processos, considerando a frequência com que os
usuários podem interagir com cada programa enquanto estão em
execução.
Como ferramenta auxiliar, o escalonamento, também denominado
agendador de processos, serve para monitorar e selecionar quais
os processos estão disponíveis, considerando até mesmo
selecionar um conjunto de processos disponíveis e executá-los no
núcleo (Figura 4).

Figura 4 | Escalonamento de processos. Fonte: adaptada de Reinecke e Conrado (2020, [s.

p.]).

Cada núcleo da CPU pode executar um processo de cada vez.

Claro que para um sistema de um único núcleo, nunca existirá
mais de um processo em execução, mas considerando que os
sistemas modernos atuam com diversos núcleos, esse não é um
cenário possível. No entanto, ainda pode ocorrer o fato de haver
mais processos do que núcleos, e neste caso, os processos em
excesso terão que esperar até que um núcleo seja liberado. O
número de processos atualmente na memória é conhecido como
o grau de multiprogramação definido pelo sistema operacional
(Tanenbaum; Woodhull, 2008).

Durante sua vida útil, um processo migra entre a fila pronta e

várias filas de espera, por isso, em sistemas operacionais, o
escalonador mapeia os processos que estão na fila pronta e aloca
um núcleo da CPU a um deles.
De acordo com Córdova Jr., Ledur e Morais (2019), o
escalonamento define os seguintes fatores:

Utilização da CPU: no qual o processamento deve ocorrer na

maior parte do tempo, executando sempre um processo.
Throughput: o sistema operacional garante que um
determinado número de processos seja executado dentro de
um período determinado.
Tempo de turnaround: deve ser considerado o tempo que
um processo consome desde que inicia até a finalização. Isso
envolve alocação da memória, o tempo de espera que os
processos levam até estar em prontos e o processamento
das operações E/S.
Tempo de resposta: caracteriza o intervalo entre a pedido do
sistema e a resposta produzida pelos processos.

Alguns sistemas operacionais têm uma forma intermediária de

escalonamento, denominada swapping, cujo propósito é que, às
vezes, pode ser vantajoso remover um processo da memória (e da
contenção ativa para a CPU) e, assim, reduzir o grau de
multiprogramação. Além das filas as quais os processos ficam em
espera para serem escalonados, o sistema também inclui outras
filas que consideram eventos como o término do processo, a
interrupção ou até mesmo quando determinado evento está
sendo aguardado para que seja possível concluir uma solicitação
de E/S (Silberschatz; Gagne; Galvin, 2015).

Como um exemplo prático, considere que o processo faça uma

solicitação de E/S para um dispositivo de armazenamento, o
disco, que por sua vez apresenta uma resposta mais lenta do que
o processador. Nesse caso, o processo terá que aguardar a
disponibilidade dos recursos de E/S para que a comunicação seja
efetivada. Aqui, considera-se que o processo está na fila,
aguardando uma ocorrência de um evento específico. Quando a
resposta retorna, o processo é realocado para a fila de executado
ou pronto (Machado; Maia, 2013).
O escalonamento de processos regras estabelecidas para definir a
prioridade de cada processo e garantir que o sistema operacional
funcione de forma sincronizada.

Vamos Exercitar?
Desafios multitarefas em sistemas
operacionais
Descrição da situação-problema

Uma empresa de e-commerce está enfrentando lentidão e

travamentos frequentes no servidor que hospeda seu site. O
servidor utiliza um sistema operacional multitarefa para processar
várias requisições simultaneamente, como acesso ao site,
consultas ao banco de dados e envio de e-mails de confirmação.
Durante picos de acesso, o desempenho do sistema degrada
significativamente, com algumas requisições demorando minutos
para serem processadas ou até sendo abandonadas.

Após uma análise inicial, o administrador do sistema descobre

que os processos críticos (consultas ao banco de dados) estão
recebendo a mesma prioridade que processos não críticos (envio
de e-mails).

O escalonador do sistema operacional está utilizando um

algoritmo FIFO (First-In, First-Out), que não considera a
prioridade ou o tempo de execução de cada tarefa, agravando o
atraso nas requisições importantes.

Resolução da situação-problema

Passo 1: reorganização de prioridades

Alterar a configuração do sistema operacional para utilizar

escalonamento baseado em prioridades.
 Atribuir prioridades mais altas para processos críticos, como:
Consultas ao banco de dados: prioridade alta.
Renderização de páginas para os usuários: prioridade
média.
Envio de e-mails de confirmação: prioridade baixa.

Passo 2: implementação de escalonamento preemptivo

Configurar o sistema operacional para usar um algoritmo de

escalonamento preemptivo, como Round Robin ou
Escalonamento por Prioridade Dinâmica.
Round Robin: distribuir o tempo de CPU de forma justa
entre os processos ativos.
Prioridade Dinâmica: ajustar a prioridade dos processos
em tempo de execução com base na sua importância e
comportamento.

Passo 3: monitoramento de processos

Utilizar ferramentas de monitoramento do sistema, como o

htop (Linux) ou o Gerenciador de Tarefas (Windows), para
identificar processos que consomem muitos recursos.
Limitar ou ajustar tarefas que não são críticas durante
horários de pico.

Passo 4: aumento da capacidade

Configurar multiprocessamento ou adicionar mais núcleos à

CPU do servidor, permitindo que várias tarefas sejam
realmente executadas em paralelo.
Otimizar o uso de memória RAM para evitar troca excessiva
de contexto.

Passo 5: testes e simulações

Simular cargas de acesso ao servidor utilizando ferramentas,

como Apache JMeter, para verificar o comportamento após
as mudanças.
Saiba Mais
Para saber mais sobre multiprocessadores, acesso o artigo: Um
sistema de programação e processamento para sistemas
multiprocessadores.

Referências Bibliográficas
ALVES, W. P. Sistemas Operacionais. 9. edição. São Paulo: Érica,
2014.

CÓRDOVA JR., R. S.; LEDUR, C. L.; MORAIS, I. S. Sistemas

Operacionais. Porto Alegre: SAGAH, 2019.

MACHADO, F. B.; MAIA, L. P. Arquitetura de Sistemas

Operacionais. 5. ed. Rio de Janeiro: Grupo GEN, 2013.

OLIVEIRA, R. S.; CARISSIMI, A. da S.; TOSCANI, S. S. Sistemas

Operacionais. 4. ed. Porto Alegre: Bookman, 2009.

REINECKE, V; CONRADO, L. F. Escalonamento com Prioridades.

[S. l.]: [s. n.], 2020. Disponível em:
[Link]
ridades/. Acesso em: 27 nov. 2024.

SILBERSCHATZ, A.; GALVIN, P. B.; GAGNE, G. Fundamentos de

Sistemas Operacionais. 9. ed. Rio de Janeiro: LTC, 2015.

SILVA, G. P. da; BORGES, J. A. dos S. Arquitetura e Organização

de Computadores: uma introdução. Rio de Janeiro: LTC, 2024.

TANENBAUM, A. S.; WOODHULL, A. S. Sistemas Operacionais:

projetos e implementação. Porto Alegre: Bookman, 2008.

WIKIWAND. Núcleo. Wikiwand, 2025. Disponível em:

[Link] Acesso em: 27 nov.
2024.
 Aula 2

CONCEITOS DE THREADS

Conceitos de threads
Olá, estudante! Nesta videoaula, conheceremos os conceitos de
threads e de múltiplas threads, assim como as vantagens e
desvantagens no uso de múltiplas threads.

O uso de múltiplos threads é uma abordagem poderosa para

melhorar o desempenho e a eficiência de aplicações,
especialmente em sistemas modernos com múltiplos núcleos de
CPU. No entanto, seu uso deve ser acompanhado de boas práticas
de programação, para evitar problemas de sincronização e
concorrência, garantindo que os benefícios superem as
desvantagens.

Esse conteúdo é importante para a sua prática profissional, pois o

entendimento sobre threads e múltiplas threads é essencial para
criar sistemas modernos que sejam rápidos, responsivos e
escaláveis.

Prepare-se para essa jornada de conhecimento! Vamos lá!

Ponto de Partida
Olá, estudante, boas-vindas!

Nesta unidade, exploraremos o conceito de threads e o processo

de multithreading e analisaremos vantagens e desvantagens
acerca da sua função em sistemas operacionais.

O sistema operacional precisa ser capaz de identificar processos e

executar tarefas constantemente, nem sempre sendo de
conhecimento do usuário todas as atividades que tramitam por
trás de sua estrutura. Os threads são definidos como processos
simplificados, por isso representam a unidade básica do
processador central de um programa. Além disso, quando um
sistema executa múltiplos threads, é possível ter maior
desempenho na execução das tarefas, no qual o mecanismo de
threads permite que processos sejam executados de forma
sequencial, mesmo que as chamadas do sistema possam
gerenciá-los e bloqueá-los quando necessário.

Veremos que os threads operam de forma semelhante a

processos e são classificadas de acordo com seus estados, suas
características e suas funcionalidades.

Vamos começar a estudar o universo dos conceitos de threads.

Bons estudos!

Vamos Começar!
Conceitos de threads
Um sistema operacional é composto de diferentes componentes.
Enquanto um processo representa uma entidade própria que
basicamente é utilizada no contexto de escalonamento
compartilhando a mesma estrutura de dados entre os processos
pai e filhos, um thread, de acordo com Scheffer (2007), é a
unidade básica de utilização de uma Unidade Central de
Processamento (CPU).

Dessa forma, quando falamos sobre a estrutura básica de um

thread, podemos considerar que é composta por uma estrutura
que permite a organização das tarefas e pode ser definida da
seguinte forma (Silberschatz; Galvin; Gagne, 2015):

ID para identificação da thread.

Contador de programa que especifica a próxima instrução a
ser executada.
Conjunto de registradores que fornecem cache das
informações para a memória principal.
Pilha, estrutura de dados ordenada.

Existem outros componentes envolvidos na operação de um

thread que fazem o compartilhamento de sua seção de código,
dados e outros recursos do sistema operacional com outros
threads. Nesse caso, ao contrário dos processos denominados pai
e filhos, a nomenclatura para threads que compartilham recursos
é threads irmãs.

Para que possamos compreender como tudo é orquestrado,

considere apenas que um processo é um programa capaz de
executar apenas um thread por vez. Dessa forma, se o usuário
estiver trabalhando em uma planilha dentro do sistema, é correto
dizer que uma única thread de instrução está sendo executada,
por isso, se o usuário precisar digitar valores e, ao mesmo tempo,
verificar a ortografia do texto que foi inserido simultaneamente,
não será possível, ou seja, não é possível executar duas tarefas
dentro do mesmo processo (Silberschatz; Galvin; Gagne, 2015).

As threads desempenham diferentes papéis dentro do sistema

operacional, entre eles, os procedimentos que são executados
remotamente, denominadas Radio Co-Processor (RCPs). As RCPs
permitem a comunicação entre os processos, basicamente da
mesma forma que são executadas as chamadas de sistema
tradicionais voltadas para os processos (Silberschatz; Galvin;
Gagne, 2015).

Fica simples compreender a funcionalidade de um thread quando

consideramos as seguintes etapas:

Uma thread encaminha uma solicitação de leitura por meio

do sistema.
Após a solicitação, a thread fica bloqueada até que os dados
estejam disponíveis.
Um processo que utiliza uma única thread não pode executá-
lo enquanto o disco está sendo acessado, ou seja, uma tarefa
por vez.

Sendo assim, suspender um processo ocasiona como

consequência a suspensão de todos os threads que estejam
atreladas a ele, considerando que eles compartilham o mesmo
espaço de endereçamento, o processo não é capaz de suspender
somente parte da tarefa.

Considerando a necessidade de uso do processamento

computacional atualmente, praticamente todos os sistemas
operacionais modernos permitem que um processo tenha
múltiplos threads de execução e seja capaz de permitir a
execução simultânea de diversas tarefas.

Conceitos de múltiplas threads e suas vantagens

Atualmente, é praticamente impossível que somente uma thread

possa atender às necessidades de quem utiliza um sistema
operacional. A limitação no uso de funcionalidades não define a
forma como o usuário utiliza as ferramentas disponíveis no
mercado. Por isso, sistemas multiprocessadores podem ter sua
operação simplificada por meio do uso de threads, de multithread!

Por isso, a maioria das aplicações de software executadas em

computadores modernos é multithread. Sobre isso, quando uma
aplicação é implementada, isso ocorre considerando um processo
separado por diversos threads de controle. Para simplificar, ele
cita o uso de um navegador de internet como um exemplo real.

O usuário realiza o acesso a um site com diversos recursos de

visualização, sendo assim, ao mesmo tempo que ele precisa
visualizar as imagens e textos que fazem parte da página
acessada, também é necessário acessar dados armazenados na
rede. Assim, duas threads podem compartilhar essas funções
(Silberschatz; Galvin; Gagne, 2015).

As aplicações precisam de fato permitir que o usuário tenha

flexibilidade para acessar os utilitários. Um processador de texto,
por exemplo, não é somente projetado para digitar, mas também
para exibir elementos, realizar correção ortográfica, receber
instruções por meio de dispositivos de E/S (entrada e saída) e
outras tarefas que podem ser executadas em segundo plano, e
para isso é necessário reconhecer a importância de um sistema
multithread.

O processador de texto é o processo, e tudo que está sendo

executado de forma simultânea são os threads atribuídos ao
processo.

O conceito de multithread, de acordo com Alves (2014), está

diretamente ligado ao processamento em sistemas multicore,
considerando que diversas tarefas podem ser executadas em
paralelo, e os núcleos trazem maior desempenho para esse
processo.

Em um sistema operacional genérico, podemos considerar que

um servidor multithread funciona da seguinte forma:

Figura 1 | Comparação de processos com único e múltiplos threads. Fonte: Silberschatz, Galvin e
Gagne (2015, p.).

Aqui, um thread depende da execução de seu código, da coleta

de dados e da forma como a execução dos arquivos é realizada.
Os registradores armazenam informações de forma temporária e
a thread é processada. Já em um sistema com múltiplos threads,
esse processo ocorre mais de uma vez simultaneamente,
considerando as mesmas condições, mas no mesmo processo.
Sistemas UNIX utilizam uma certa fatia da memória livre do
sistema para gerenciar as interrupções, o armazenamento de
informações importantes e as instruções que devem ser seguidas
para que o ambiente alcance um melhor desempenho.
Na Figura 2, podemos analisar a arquitetura de um servidor
multithread.

Figura 2 | Sistema de servidor multithread. Fonte: Silberschatz, Galvin e Gagne (2015, p. 92).

Podemos analisar que, sempre que o cliente solicita ao servidor

que uma funcionalidade seja executada, uma nova thread é criada
e o servidor retorna à requisição, permitindo a execução de
determinada tarefa. Isso pode ocorrer repetidas vezes, de acordo
com a capacidade de processamento do sistema operacional e do
núcleo. Os benefícios da programação com múltiplos threads
podem ser divididos em quatro categorias principais: capacidade
de resposta, compartilhamento de recursos, economia e
escalabilidade (Bill, 2021). Além disso, aplicações podem
alavancar as capacidades de processamento e uma única
aplicação pode ser executada diversas vezes para tarefas
semelhantes.

Podemos concluir que a maioria dos sistemas operacionais

multiprocessadores é multithread, o que permite facilitar
processos desde o gerenciamento de dispositivos, o
gerenciamento da memória ou a manipulação de tarefas sem que
isso cause exaustivas interrupções.

Siga em Frente...
Desvantagens no uso de múltiplas threads
Apesar de os sistemas que trabalham com multithread serem uma
evolução em termos de processamento de informações e
execução de processos, assim como qualquer tecnologia, também
existem desvantagens e, neste caso, a principal delas ao executar
vários threads de forma simultânea está ligada à complexidade do
ambiente. Sendo assim, existe um receio sobre o fato de os
threads, acessando os recursos ao mesmo tempo, causarem
corrompimento nos dados, ocasionado pela sua interação. É
importante lembrar que os threads estão relacionados com
processos, e qualquer ação que envolva a sincronização incorreta
pode causar problemas relacionados com a prioridade das
tarefas.

Ao dividir um programa em vários processos, os threads podem

ter sua funcionalidade caracterizada por vantagens e
desvantagens atribuídas à forma como são aplicadas ao sistema
operacional, justamente pela interação entre eles e os recursos
necessários. Na Figura 3, podemos notar como um processo pode
ser executado com três threads compartilhando o mesmo
ambiente de compartilhamento.
 Figura 3 | Compartilhamento entre threads. Fonte: adaptada de Machado e Maia (2013, p. 3).

Apesar de trazer diversos benefícios relacionados ao processo de

desenvolvimento mais fácil, à criação de programas em módulos e
aos testes de ambiente, o trabalho multithread se torna mais
complicado. É necessário analisar a execução multithread, pois
algumas outras desvantagens podem ser consideradas, como o
uso de um ambiente multithread que pode causar interferência
entre threads que compartilham recursos de hardware entre si,
em casos em que a utilização desses recursos sobrecarregue a
capacidade. Além disso, pode existir uma perda de performance,
devido à frequência mais lenta e/ou aos estágios de pipeline
adicionais necessários para acomodar o hardware de comutação
de thread, ainda mais considerando que são necessárias múltiplas
alterações no sistema operacional. Outra desvantagem é a
dificuldade no gerenciamento de concorrência entre os threads
em execução no sistema operacional.
Para resolver esses problemas, podemos definir dois tipos de
multithread (Oliveira; Carissimi; Toscani, 2009):

Multithread preemptiva: permite o controle dos processos

executados por meio do processador, isso evita travamentos
aos programas. Esse método aplica uma forma de
interromper o programa temporariamente sem que seja
necessário grande esforço, o que permite que seja retomado
posteriormente.
Multithread cooperativa: permite executar mais de um
programa, porém o programa em primeiro plano controla a
capacidade de processamento.

Quando se busca desempenho e eficiência, o uso de multithread

é o melhor caminho, principalmente quando se trata de
informações em tempo real: jogos on-line, comunicação síncrona,
execução de áudio e vídeo ao mesmo tempo. Essas atividades
com o uso de uma única thread seriam inviáveis por exigir que
recursos sejam executados simultaneamente. No entanto,
Córdova Jr., Ledur e Morais (2019) afirmam que, diferente do que
ocorre em um ambiente single thread, é necessário tratar de
múltiplas variáveis e ter o conhecimento necessário para garantir
um bom resultado na execução de processos.

A comunicação entre tarefas é simplificada quando existe

implementação baseada em múltiplas threads, ainda mais
considerando que as tarefas compartilham o espaço de
endereçamento de memória e caracterizam um processo como
um todo que engloba os threads, eliminando a necessidade de
restrições ou gerando problemas que possam influenciar
negativamente na comunicação entre processos providos pelos
sistemas operacionais. São poucas as desvantagens que podem
ser atribuídas ao uso de multihread, porém é necessário ter
cuidado na forma como o sistema é executado, mantendo
atenção a qualquer alerta de problemas relacionados à sua
funcionalidade.
Vamos Exercitar?
Ineficiência em um servidor web devido ao
uso de processos em vez de threads
Descrição da situação-problema

Uma empresa de tecnologia está enfrentando problemas de

desempenho em seu servidor web, que processa
simultaneamente centenas de requisições de usuários. O servidor
foi projetado para criar um novo processo para cada requisição
recebida. Isso resulta em:

Alto consumo de memória: cada processo possui seu próprio

espaço de memória, sobrecarregando o sistema.
Troca de contexto frequente: o tempo gasto para alternar
entre processos é elevado.
Lentidão no processamento: durante picos de tráfego, o
servidor se torna incapaz de atender a todas as requisições,
resultando em atrasos e falhas.

O modelo baseado em processos está criando sobrecarga

desnecessária no sistema operacional devido à duplicação de
recursos e ao custo de troca de contexto. Qual solução você
apresentaria para essa situação?

Resolução da situação-problema

Utilizar threads em sistemas que exigem alta concorrência é uma

solução eficiente, pois elas permitem o compartilhamento de
recursos e reduzem o overhead de gerenciamento de processos.
No entanto, é essencial implementar mecanismos de
sincronização para evitar conflitos ao acessar recursos
compartilhados. Essa abordagem garante que o sistema seja mais
escalável e responsivo.
Passo 1: redesenho do servidor para uso de threads

Substituir o modelo baseado em processos por um modelo

baseado em threads.
Implementar um pool de threads, no qual um número fixo de
threads é criado no início, e cada thread é reutilizada para
processar múltiplas requisições.

Passo 2: implementação da sincronização

Adicionar mecanismos de sincronização para evitar

problemas de acesso simultâneo a recursos compartilhados.
Utilizar mutexes para proteger seções críticas.
Implementar variáveis de condição para coordenar
threads.

Passo 3: teste de carga

Usar ferramentas, como Apache JMeter, para simular

múltiplas requisições ao servidor e monitorar o desempenho.
Comparar o desempenho do novo modelo baseado em
threads com o modelo anterior.

Passo 4: monitoramento contínuo

Implantar ferramentas de monitoramento, como htop ou New

Relic, para acompanhar o consumo de recursos do servidor e
identificar possíveis gargalos.

Saiba Mais
Aprenderemos sobre uma comparação prática entre sistema
multitarefa e multithread: UNIX e NT.

Referências Bibliográficas
ALVES, W. P. Sistemas Operacionais. 9. ed. São Paulo: Érica, 2014.
BILL. Threads e threading. Microsoft, 2021. Disponível em:
[Link]
ds-and-threading. Acesso em: 2 nov. 2024.

CÓRDOVA JR., R. S.; LEDUR, C. L.; MORAIS, I. S. Sistemas

Operacionais. Porto Alegre: SAGAH, 2019.

MACHADO, F. B.; MAIA, L. P. Arquitetura de Sistemas

Operacionais. 5. ed. Rio de Janeiro: Grupo GEN, 2013.

OLIVEIRA, R. S.; CARISSIMI, A. da S.; TOSCANI, S. S. Sistemas

Operacionais. 4. ed. Porto Alegre: Bookman, 2009.

SCHEFFER, R. Uma visão sobre Threads. Campo Dig., Campo

Mourão, v. 2, n. 1, p. 7-12, jan./jun. 2007. Disponível em:
[Link]
/article/download/311/145. Acesso em: 2 nov. 2024.

SILBERSHATZ, A.; GALVIN, P. B., GAGNE, G. Fundamentos de

sistemas operacionais. 9. ed. Rio de janeiro: LCT, 2015.

Aula 3

FUNCIONALIDADE DE
PROCESSOS E THEADS

Funcionalidade de processos e
threads
Olá, estudante! Nesta videoaula, conheceremos sobre os estados
de threads, a comunicação entre processos em sistemas
operacionais Linux e o modelo de implementação de threads.

A gestão de threads e a comunicação entre processos são pilares

fundamentais dos sistemas operacionais modernos. Entender os
estados de threads ajuda no design eficiente de programas
multithread, enquanto os mecanismos de IPC em Linux facilitam a
troca de informações entre processos.

A escolha do modelo de implementação de threads deve

equilibrar desempenho e simplicidade, dependendo das
necessidades da aplicação.

Esse conteúdo é importante para a sua prática profissional, pois

permite criar soluções robustas e otimizadas, garantindo que as
aplicações aproveitem ao máximo os recursos disponíveis. Para
profissionais de TI, especialmente desenvolvedores, engenheiros
de software e administradores de sistemas, dominar esses
conceitos é indispensável para enfrentar desafios do mercado e
entregar soluções tecnicamente avançadas.

Prepare-se para essa jornada de conhecimento! Vamos lá!

Ponto de Partida
Olá, estudante, boas-vindas!
Nesta unidade, veremos sobre os estados de threads, a
comunicação entre processos em sistemas operacionais Linux e o
modelo de implementação de threads.

Uma das formas de compreendermos o funcionamento de uma

thread é exercer a prática da análise inicial de um processo. Os
sistemas, em sua maioria, acabam baseando-se em computadores
que disponibilizam somente um processador, o qual realiza
diversas atividades de forma simultânea, ou seja, diferentes
processos compartilham o uso da CPU, levando a um tempo
extensivo para execução.

Bons estudos!

Vamos Começar!
Estados de threads
Quando um processo é iniciado, observa-se o seu alto custo
naquilo que se refere à utilização de memória e comportamento.
Além disso, o mecanismo de troca de mensagens caracteriza-se
por ser mais lento e com elevado nível de complexidade em
comparação a um único programa que acessa uma base de dados
própria.

É importante mencionar que uma possível solução a ser adotada

está relacionada ao uso das threads (linhas de execução). Por
definição, thread é um subprocesso inerente a um processo, que
possibilita dividir a sua área de dados com o programa ou até
mesmo threads (Oliveira; Carissimi; Toscani, 2009).

O começo de uma thread apresenta uma velocidade superior do

que um processo, além do fato de haver o acesso à sua área, que
atua como um programa único. A implementação das threads na
Java Virtual Machine (JVM), por exemplo, segue duas abordagens
básicas (Figura 1).
 Figura 1 | Implementação de threads. Fonte: elaborada pelo autor.

Vale ressaltar que as threads formadas por mecanismos nativos

do Sistema Operacional caracterizam-se por sua maior
velocidade. Por sua vez, a implementação do JVM apresenta uma
independência completa da plataforma. Em ambas as situações, a
implementação ocorre por meio do uso de uma parte do tempo.

De acordo com Silberschatz, Galvin e Gagne (2015), ao

observarmos a execução de um thread, é preciso levar em
consideração os seus estados, conforme se observa na Figura 2, a
seguir.

Figura 2 | Estados de uma thread. Fonte: Cavalcanti (2021).

Ao ser criada, a thread está inserida em seu estado novo: isto
indica quando a área é alocada para ela por meio do operador
new. No momento em que é desenvolvida, a thread passa a ser
registrada em uma JVM, para que ocorra a sua execução.

Quando ativada, a thread se encontra no estado executável. Vale

mencionar que o método start () origina o processo de ativação. A
JVM ou o S.O. determinam o tempo de sua execução, portanto é
válido frisar que um thread executável não está, necessariamente,
sendo executada.

A desativação indica que a thread está em estado bloqueado.

Para iniciar o processo de desativação de um thread, é preciso
que uma das quatro operações (Figura 3) a seguir ocorra
efetivamente:

Figura 3 | Quatro operações. Fonte: elaborada pelo autor.

O estado bloqueado pode retornar ao estado executável, sendo

preciso que uma das operações a seguir aconteça em oposição a
algumas atividades observadas na Figura 3, como:

O retorno após o tempo especificado, caso a thread esteja

adormecida, por exemplo.
O retorno por meio do método resume (), na hipótese de
haver suspensão da thread.
 A volta através do método notify (), caso a thread se encontre
em estado de espera.
A volta depois da conclusão da operação de I/O.

É importante observar que a thread estará inserida em estado

encerrado quando a sua execução também terminar. Certamente,
isso ocorre graças ao encerramento do método run (), ou por
conta da chamada explícita do método stop ().

Sendo assim, como você pode notar, existe uma maneira de

entender e analisar o funcionamento de uma thread, que é
realizar a prática da avaliação de um processo no seu início. Em
sua maioria, os sistemas pautam-se nos computadores, que
disponibilizam apenas um processador, o qual executa inúmeras
atividades de forma simultânea.

Comunicação entre processos em sistemas

operacionais Linux

Quando observamos um sistema operacional, é preciso visualizar

a comunicação existente entre os processos. Tratando
especificamente do Sistema Linux, devemos observar que o uso
das técnicas e dos métodos disponibilizados pela comunicação
entre processos, ou o inter-process communication (IPC), atende
à necessidade existente de troca das informações dos processos
que são executados pelos sistemas operacionais.

De acordo com Alves (2014), a ideia de comunicação de processos

não se limita ao meio de comunicação do sistema operacional ou
até mesmo do próprio computador; isso se justifica pelo fato de a
origem e a destinação da comunicação estarem separadas por
distâncias quilométricas, ligadas somente por meio de redes.
Determinados métodos não possibilitam essa troca de
informações, usando somente as redes, pois, neste caso, o escopo
de comunicação local acaba sendo aceitável (Fenerich, 2016).
A comunicação entre processos está condicionada ao uso
adequado dos comandos pertencentes ao Sistema Linux. Um
desses comandos é o top, que se caracteriza por apresentar os
processos em execução no sistema, além de ser um instrumento
relevante direcionado para um administrador do sistema. É um
comando muito adotado para estabelecer um monitoramento da
carga do sistema, além de ser interativo, possibilitando que
diversos comandos estejam disponíveis quando ele estiver em
execução.

Por sua vez, o comando os (), em Linux, possibilita adquirir

informações referentes ao estado dos processos que estão sendo
realizados no momento, de modo que tais informações são
observadas na saída padrão do sistema. Trata-se de um
mecanismo importante, destinado ao administrador do sistema,
que, com ele, pode adquirir uma gama de informações para
entender o que está acontecendo com a máquina em um
determinado período.

Dentro desse contexto, podemos entender o conceito de shell,

que é o programa que viabiliza, em um modo texto, a interação do
usuário com o sistema. Há diversos modelos de shell, cujas
funcionalidades podem ser observadas no modelo a seguir:
 Figura 4 | Modelos de Shell. Fonte: elaborada pelo autor.

O modelo Bourne shell (sh) é o mais antigo, sendo

encontrado em, praticamente, todos os sistemas, devido à
sua procura nas mais variadas operações administrativas.
O C shell (csh) caracteriza-se por apresentar uma sintaxe
mais simplista e facilitada. É considerado como o shell
default do sistema Solaris.
O Korn shell (ksh) acaba juntando os aspectos principais dos
modelos citados anteriormente. Uma dessas utilizações
ocorre em IBM e HP.
Já o Bash shell (bash) é uma extensão do sh, sendo usado
como padrão nas máquinas Linux.

No Shell, os comandos podem ser demonstrados por meio da

utilização do método IPC, denominado Pipe. Segundo Alves
(2014), é um canal que une dois processos dentro das suas
extremidades. Tal recurso possibilita que ocorra o tráfego das
informações de um processo ao outro, porém com a condição de
fazê-lo somente em um único direcionamento.

Os pipes caracterizam-se por possibilitarem que informações

sejam remetidas de um processo a outro, assegurando um nível
de comunicação mais elevado. É importante frisar que algumas
usabilidades estão inseridas na rotina de diversos profissionais
que adotam o sistema Linux como padrão. Em outras palavras, é
possível verificar que o caractere pipe (‘’/’’) pode ser visto como
um recurso que informa ao shell que um canal de comunicação
será estabelecido entre os dois processos (comandos).

Siga em Frente...
Tipos de implementação de threads
O núcleo do sistema operacional tem a função de gerenciar as
threads que estão inseridas nos processos estabelecidos no
espaço do usuário. Certamente, esse gerenciamento pode ser
executado de diversas maneiras, de acordo com a implementação
de threads adequada (Tanenbaum; Woodhull, 2008).

O primeiro modelo que podemos observar está relacionado ao

nível de usuário. Os processos sequenciais eram suportados pelos
sistemas operacionais mais antigos, cabendo aos desenvolvedores
de aplicações solucionarem esses problemas a partir da
construção de bibliotecas, com a função de modificar e recuperar
os registradores de CPU no processo. Tais bibliotecas permitem
que diversas threads sejam lançadas por meio de uma aplicação,
de acordo com a sua demanda, entretanto o núcleo realizará o
gerenciamento de um fluxo de execução dos processos de forma
individualizada.

Segundo Córdova Jr., Ledur e Morais (2019) e Maziero (2019), essa

implementação de threads é chamada de modelo de Threads N:1,
já que N threads estarão inseridas em um processo, sendo
mapeadas em uma única thread no núcleo, conforme se observa
na figura a seguir.
 Figura 5 | Modelo de Threads N: 1. Fonte: Maziero (2019).

É um modelo muito procurado por conta da leveza e da

implementação facilitada. Cabe destacar que o nível de
gerenciamento imposto ao núcleo é limitado e independe da
quantidade de threads dentro da aplicação, já que o núcleo
visualiza somente uma thread. Certamente, isso viabiliza o
desenvolvimento de aplicações que demandam uma quantidade
maior de threads, como os grandes sistemas. Por sua vez, o
modelo de Threads N:1 apresenta problemas, que podem ser
visualizados na Figura 7, a seguir.
Figura 6 | Modelo de Threads N:1. Fonte: Maziero (2019).
O segundo modelo que podemos observar está relacionado ao
nível de kernel. De acordo com Maziero (2019), a cada thread de
usuário pode ser associada uma thread correspondente no
núcleo, o que acaba descartando a necessidade de bibliotecas de
threads. Tal implementação é chamada de Modelo de Threads 1:1
(conforme se observa na Figura 8), muito presente em sistemas
operacionais como o Windows e a maioria dos UNIXes.

Figura 7 | Modelo de Threads N:1. Fonte: Maziero (2019).

Uma das vantagens desse modelo está na resolução de

problemas: se, porventura, uma thread de usuário de mandar uma
operação bloqueante, será suspensa apenas sua thread de núcleo
correspondente, não impactando as demais threads do processo.
Trata-se de um modelo adaptado para situações mais usuais,
porém é pouco escalável, pois o desenvolvimento de várias
threads impossibilita aplicações multitarefas.

Um modelo híbrido é adotado para a resolução das questões que

envolvem a escalabilidade da abordagem 1:1, agregando
características dos modelos anteriores. De acordo com Maziero
(2019), a biblioteca gerencia uma série de N threads de usuário,
que é mapeada em M <N threads no núcleo, conforme pode ser
observado na Figura 9 a seguir.

Figura 8 | Modelo de Threads N:M. Fonte: Maziero (2019).

Esse modelo consegue aliar as vantagens de uma interatividade

mais elevada do modelo 1:1 ao nível de escalabilidade maior do
modelo N:1. Por sua vez, a gerência das threads, com seu nível
elevado de complexidade na implementação e maior custo,
quando comparados ao modelo 1:1, pode ser vista como uma das
desvantagens desse modelo.

Vamos Exercitar?
Escolha ineficiente do tipo de implementação
de threads em uma aplicação
multiplataforma
Descrição da situação-problema
Uma empresa de software desenvolveu uma aplicação
multiplataforma para processamento de dados em tempo real. A
aplicação foi projetada para rodar em diferentes sistemas
operacionais (Windows, Linux e macOS) e precisa realizar diversas
tarefas simultaneamente, como leitura de arquivos, análise de
dados e envio de resultados para servidores remotos.

Na implementação inicial, os desenvolvedores optaram por

threads no nível de usuário, considerando que esse modelo seria
mais eficiente devido à sua leveza e independência do
escalonador do sistema operacional. No entanto, problemas
começaram a surgir:

Baixo desempenho em sistemas multicore: apesar do

hardware suportar múltiplos núcleos, a aplicação não
conseguiu distribuir as threads adequadamente entre eles,
pois o escalonador do sistema operacional não reconhece
threads no nível de usuário.
Baixa portabilidade e inconsistências: as bibliotecas usadas
para gerenciar threads no nível de usuário apresentaram
comportamentos diferentes em cada sistema operacional,
causando falhas e erros imprevisíveis.
Dificuldade de debugging: diagnosticar e corrigir problemas
tornou-se difícil, pois as ferramentas padrão de depuração
não conseguiam rastrear as threads gerenciadas em nível de
usuário.

O que você indicaria de solução para essa situação?

Resolução da situação-problema

Escolher o tipo correto de implementação de threads é crucial

para atender aos requisitos de desempenho, portabilidade e
manutenção de uma aplicação. Enquanto threads no nível de
usuário podem ser úteis em cenários simples ou específicos,
threads no nível de kernel são ideais para aplicações que exigem
escalabilidade e suporte multiplataforma robusto. Compreender
as características de cada modelo é essencial para tomar decisões
técnicas eficientes.

Passo 1: análise e redefinição da estratégia

Os desenvolvedores decidiram migrar para um modelo de threads

no nível de kernel, que permite que o sistema operacional
gerencie diretamente as threads e as distribua entre os núcleos
disponíveis. Essa abordagem maximiza o uso do hardware
multicore e melhora o desempenho geral.

Passo 2: implementação

Alteração do código para utilizar as APIs nativas de threads

fornecidas pelo sistema operacional (como Pthreads, no
Linux/macOS, e WinAPI, no Windows).
Adaptação da lógica de sincronização para utilizar
mecanismos padrão de controle de concorrência disponíveis
nessas APIs, como mutexes e semáforos.

Passo 3: teste multiplataforma

Executar testes detalhados em cada sistema operacional

para garantir que as threads funcionem corretamente e
sejam escalonadas pelo kernel.
Monitorar o uso de recursos e o desempenho geral utilizando
ferramentas específicas, como htop, no Linux, ou Task
Manager, no Windows.

Passo 4: manutenção e documentação

Documentar o novo modelo de threads para garantir que

futuras implementações sigam os mesmos padrões.

Adotar práticas para facilitar o debugging, como incluir logs e

utilizar ferramentas de monitoramento de threads compatíveis
com o nível de kernel.
Saiba Mais
Para saber mais sobre o uso das threads na prática, acesse o
artigo HetNOS Threads: Programação Multithreaded Distribuída.

Referências Bibliográficas
ALVES, W. P. Sistemas Operacionais. 9. ed. São Paulo: Érica, 2014.

FENERICH, F. C. Administração dos sistemas de operações.

Curitiba: Intersaberes, 2016.

CÓRDOVA JR., R. S.; LEDUR, C. L.; MORAIS, I. S. Sistemas

Operacionais. Porto Alegre: SAGAH, 2019.

MAZIERO, C. A. Sistemas operacionais: conceitos e mecanismos.

Curitiba: DINF - UFPR, 2019.

OLIVEIRA, R. S.; CARISSIMI, A. da S.; TOSCANI, S. S. Sistemas

Operacionais. 4. ed. Porto Alegre: Bookman, 2009.

SILBERSCHATZ, A.; GALVIN, P. B.; GAGNE, G. Fundamentos de

Sistemas Operacionais. 9. ed. Rio de Janeiro: LTC, 2015.

TANENBAUM, A. S.; WOODHULL, A. S. Sistemas operacionais.

Porto Alegre: Grupo A, 2008.

Aula 4

PROCESSOS NA PRÁTICA

Processos na prática
Olá, estudante! Nesta videoaula, exploraremos os conceitos de
processos em sistemas operacionais e gerenciamento de tarefas,
comunicação entre processos sem sistemas operacionais Linux e
comunicação entre processos sem sistemas operacionais
Windows.

Processos são instâncias em execução de programas em um

sistema operacional. Cada processo tem seu próprio espaço de
memória e recursos, podendo interagir com outros processos ou
com o sistema operacional para realizar tarefas específicas. O
gerenciamento de processos é crucial para garantir que o sistema
funcione de forma eficiente, alocando corretamente recursos,
como CPU e memória, entre os processos em execução. Esse
gerenciamento inclui a criação, a execução, o escalonamento, a
interrupção e o término dos processos.

Esse conteúdo é importante para a sua prática profissional, pois a

compreensão desses conceitos é crucial para garantir a eficiência,
a segurança e a escalabilidade dos sistemas operacionais, além
de ser uma competência essencial para profissionais que atuam
na administração de sistemas, desenvolvimento de software e
otimização de infraestruturas tecnológicas.

Prepare-se para essa jornada de conhecimento! Vamos lá!

Ponto de Partida
Olá, estudante, boas-vindas!

Nesta unidade, veremos sobre processos em sistemas

operacionais e gerenciamento de tarefas, comunicação entre
processos sem sistemas operacionais Linux e comunicação entre
processos sem sistemas operacionais Windows.

A comunicação entre processos é fundamental dentro de um

sistema operacional. Para isto, é necessário o uso de diversos
mecanismos de implementação. É comum observar que os dados
podem ser compartilhados entre os aplicativos.

Sendo assim, ao longo desta aula, debateremos sobre a

comunicação realizada entre os processos dentro do sistema
Windows, os mecanismos de IPC adotados e a funcionalidade do
gerenciamento de tarefas para solucionar problemas com os
processos.

Bons estudos!

Vamos Começar!
Processos em sistemas operacionais e
gerenciamento de tarefas
Todo sistema operacional é composto, entre outros elementos,
por diversos processos em execução. Naturalmente, cada
processo pode apresentar falhas durante sua execução, o que
exige uma gestão eficiente de suas tarefas.

Conforme explica Tanenbaum (2005), um processo pode ser

definido como uma instância de um programa em execução. Ele
inclui um conjunto de informações essenciais para permitir a
concorrência entre programas, além de fornecer o ambiente
necessário para a execução do programa. Vale destacar que,
quando um processo é substituído por outro, ocorre uma
mudança de contexto. Cada processo pode ser dividido em três
partes principais, como ilustrado na figura a seguir.
Figura 1 | Contexto do processo. Fonte: elaborada pela autora.
O contexto de hardware refere-se a uma etapa essencial no
processamento de informações, em que o conteúdo dos
registradores gerais e dos registradores específicos de uma CPU é
armazenado temporariamente. Esse armazenamento é necessário
para garantir a integridade das operações, permitindo que o
sistema possa alternar entre diferentes processos de maneira
eficiente e segura (Alves, 2014). Já o contexto de software está
relacionado às características e às especificidades dos recursos
disponíveis no sistema que serão alocados para um determinado
processo. Esses recursos incluem elementos, como variáveis,
threads, memória e outras funcionalidades necessárias para o
funcionamento adequado do processo. O espaço de
endereçamento, por sua vez, representa a área de memória
designada exclusivamente para armazenar as instruções e os
dados utilizados durante a execução de um processo (Machado;
Maia, 2013). Essa área é fundamental para garantir que o
processo funcione de maneira isolada, evitando conflitos ou
interferências com outros processos em execução.

Diante desse cenário, é natural que, em algum momento, o

usuário de um sistema operacional encontre situações em que um
programa, aparentemente encerrado, não possa ser reiniciado.
Pode ocorrer, por exemplo, que o usuário tente executar
novamente o programa e não obtenha sucesso, ou receba uma
mensagem indicando que uma instância do aplicativo já está em
execução. Essa situação pode ser causada por falhas na liberação
de recursos ou pelo bloqueio do contexto associado ao processo
anterior. Para resolver essas questões, uma das soluções mais
práticas e eficazes é utilizar o gerenciador de tarefas, uma
ferramenta nativa da maioria dos sistemas operacionais
modernos. Com ela, o usuário pode identificar o processo
problemático, encerrá-lo manualmente e liberar os recursos
necessários para permitir a execução normal do aplicativo.
Para acessar o gerenciador de tarefas, é preciso combinar Ctrl +
Alt + Del. Através de uma janela, é preciso acessar a aba
“Processos”, conforme se visualiza na figura a seguir.

Figura 2 | Gerenciador de tarefas do Windows. Fonte: captura de tela do gerenciador de tarefas

do Windows.

É possível observar que, a princípio, a lista de processos pode não

ser muito extensa, pelo fato de que o gerenciador de tarefas
estabelece uma filtragem em alguns processos por padrão. Para
obter a visualização completa dessa relação, é preciso clicar no
botão “Mostrar processos de todos os usuários”.

Devemos frisar que o gerenciador de tarefas é formado por um

conjunto de guias que facilitam a execução de atividades, de
acordo com a figura a seguir.
 Figura 3 | Guias do gerenciamento de tarefas. Fonte: captura de tela.

A guia Processos demonstra a execução de aplicativos e planos

ocorridas no segundo plano; a guia Performance demonstra os
gráficos e os detalhes das principais medições de desempenho de
um computador; a guia Histórico de Aplicativo demonstra o total
de recursos utilizados pelos aplicativos individuais; a guia
Inicialização (Startup) altera a funcionalidade da guia Startup no
MsConfig.

Existem, ainda, outras guias voltadas à resolução de outras

questões mais específicas, como a guia Usuários, que exibe os
processos que estão em execução em cada sessão; a guia Monitor
de Sistema, que disponibiliza os recursos utilizados pelos
componentes principais do sistema; por fim, a guia Detalhes e
Serviços, que apresenta informações idênticas àquelas que estão
no gerenciador de tarefas antigo.

Sendo assim, vemos a importância do gerenciador de tarefas,

principalmente na resolução de problemas e na execução de
processo.

Comunicação entre processos sem sistemas

operacionais Linux
Métodos e técnicas desempenham um papel crucial no
gerenciamento e na coordenação da troca de informações entre
os processos que operam em um sistema operacional. Esses
processos precisam comunicar-se de forma eficiente para garantir
que o sistema funcione de maneira integrada, atendendo às
demandas das aplicações e dos usuários. É essencial destacar
que essa comunicação entre processos não está limitada ao
ambiente interno de um único computador (Silberschatz; Galvin;
Gagne, 2015). Ela pode se expandir, utilizando redes para
possibilitar a interação entre diferentes sistemas, o que é
especialmente relevante em ambientes distribuídos e na
computação em nuvem.

No contexto do sistema Linux, há uma ampla gama de métodos e

técnicas projetados para implementar a comunicação entre
processos, conhecida como Inter-Process Communication (IPC).
Esses métodos possibilitam que processos independentes
troquem informações, sincronizem suas atividades e cooperem
entre si. Dentre os diversos métodos disponíveis, destaca-se o
uso de sinais. De acordo com Fenerich (2016), os sinais
representam uma das formas mais simples e primitivas de
comunicação entre processos. Apesar de sua simplicidade, eles
são extremamente úteis para notificar processos sobre a
ocorrência de eventos específicos. Contudo, ao contrário de
outros métodos de IPC que transmitem informações completas,
os sinais não carregam dados tradicionais. Em vez disso, atuam
como indicadores que instruem o processo a realizar uma ação
predeterminada.

Os sinais podem ser entendidos como interruptores de software.

Para Machado e Maia (2013), eles têm a importante função de
alertar o processador sobre a ocorrência de eventos que
demandam a interrupção do fluxo normal de processamento. Isso
pode ocorrer devido a uma necessidade operacional, como o
término de um processo filho, ou por conta de problemas
inesperados, como erros no sistema. Ao interromper o trajeto de
processamento natural, os sinais permitem que o sistema
responda rapidamente às condições emergentes, garantindo
maior estabilidade e controle.

Vale lembrar que é importante mencionar que existe uma ampla

variedade de sinais, cada um associado a ações padrão definidas
pelo sistema. Essas ações são executadas automaticamente caso
o processo não implemente um tratamento personalizado para o
evento gerado pelo sinal. Entre as ações padrão, incluem-se o
término do processo, a suspensão temporária de sua execução e a
geração de diagnósticos. A figura apresentada a seguir ilustra um
conjunto de sinais padrão e suas respectivas ações,
demonstrando como esse método é estruturado e utilizado para
gerenciar eventos no sistema Linux.

Figura 4 | Ações padronizadas utilizando o método sinal. Fonte: elaborada pelo

autor.

Um método amplamente utilizado no sistema Linux é o Pipe, que,

conforme descrito por Alves (2014), pode ser entendido como um
canal que interliga dois processos situados em suas extremidades.
Esse recurso permite que as informações sejam transportadas de
um processo para outro em um fluxo contínuo, garantindo uma
comunicação eficaz e sem interrupções. Diferentemente dos
sinais, que notificam eventos e requerem que o processo trate as
informações adequadamente, o Pipe facilita a transferência direta
de dados entre processos, assegurando um nível mais elevado de
comunicação (Córdova Jr.; Ledur; Morais, 2019).

Como o Pipe é aplicado efetivamente no sistema Linux? O

caractere pipe (|) serve como um símbolo que instrui o Shell a
estabelecer um canal de comunicação entre dois comandos. Por
exemplo, ao utilizar o comando ls | grep "Meu Arquivo", o
comando ls envia sua saída padrão (stdout) diretamente para a
entrada padrão do comando grep. Nesse caso, o comando ls
gerará uma listagem de arquivos e o comando grep procurará por
um arquivo específico chamado “Meu Arquivo”, retornando os
resultados através da saída padrão. Essa técnica é extremamente
útil para processar informações em tempo real, como filtrar dados
de texto e buscar padrões, uma operação comum em tarefas de
análise e manipulação de dados.

Segundo Alves (2014), o método Pipe é baseado na ideia de que

os processos envolvidos na comunicação devem estar
relacionados, formando uma hierarquia de tipos “pai” e “filho”.
Isso significa que não é possível trocar informações entre
processos que não mantêm qualquer relação. O Pipe não fornece
um endereçamento direto entre processos distintos e sem
conexão estabelecida, limitando a comunicação a processos que
compartilham uma relação hierárquica. A utilização mais
frequente dessa técnica está associada à criação de processos
filhos através do sistema FORK() (Silva; Borges, 2024).

Quando o comando FORK() é executado, o processo atual é

duplicado e continua sua execução a partir do ponto em que o
FORK() foi chamado. Essa duplicação é crucial, pois permite que o
Pipe criado pelo processo pai seja mantido para o processo filho.
Isso significa que ambos os processos compartilham o mesmo
canal de comunicação, permitindo trocas de informações
contínuas e sincronizadas. Essa abordagem é particularmente útil
em situações nas quais é necessário processar informações de
forma paralela, como em pipelines de processamento de dados,
em que um processo se encarrega de preparar os dados para o
próximo, sem necessidade de armazená-los em arquivos
temporários (Oliveira; Carissimi; Toscani, 2009).

A eficácia do Pipe também está relacionada ao seu uso em

conjunto com comandos poderosos do Shell, como grep, awk, sed
e sort. Esses comandos podem ser empilhados uns sobre os
outros através de Pipes para realizar operações complexas em
dados. Por exemplo, um pipeline pode começar com ls | grep
"Meu Arquivo" | sort -r, em que ls gera uma lista de arquivos, grep
filtra o nome específico e sort -r ordena a saída de forma reversa.
Essa técnica é essencial para otimizar processos e tarefas em
ambientes Linux, facilitando a manipulação de grandes volumes
de dados de maneira rápida e eficiente.

Em resumo, o método Pipe no sistema Linux oferece uma solução

poderosa para a comunicação entre processos, permitindo que
dados sejam trocados de forma eficiente e contínua. A
capacidade de empilhar comandos e realizar operações
complexas em uma única linha de comando demonstra a
flexibilidade e a utilidade dessa técnica em diversas situações.
Além disso, a hierarquia de processos estabelecida por meio do
Pipe garante que a comunicação seja segura e organizada,
evitando conflitos e garantindo a integridade dos dados. Essa
abordagem é essencial para os usuários Linux que precisam
processar informações rapidamente, seja em tarefas de filtragem,
busca ou processamento de dados em tempo real, tornando o
Pipe uma ferramenta fundamental no arsenal de qualquer
administrador ou desenvolvedor de sistemas Linux.

Siga em Frente...
Comunicação entre processos sem sistemas
operacionais Windows
A comunicação entre processos em sistemas operacionais sem
um sistema operacional como o Windows envolve métodos e
técnicas específicas que visam permitir que processos distintos
troquem informações e coordenem suas operações de maneira
eficiente (Oliveira; Carissimi; Toscani, 2009). Esses sistemas,
geralmente, não oferecem uma interface gráfica tão robusta
quanto o Windows, e muitas vezes dependem de comandos
baseados em texto, o que exige um conhecimento mais profundo
das ferramentas disponíveis e dos sistemas operacionais em uso.

Em sistemas Unix-like, como o Linux e o macOS, a comunicação

entre processos pode ser realizada de diversas maneiras. Uma das
mais comuns é através de sistemas de arquivos e pipes. Os pipes
são canais que permitem a transferência de dados entre dois
processos. Eles são frequentemente utilizados para redirecionar a
saída de um comando para a entrada de outro, criando um
pipeline de processos que trabalham juntos para realizar tarefas
complexas (Alves, 2014). Por exemplo, o comando ls | grep
"Arquivo" é um pipeline em que a saída do comando ls (listagem
de arquivos) é enviada para o comando grep para filtrar os
arquivos de interesse.

Outra forma comum de comunicação entre processos sem

sistemas Windows é o uso de FIFO (First In, First Out), que são
semelhantes aos pipes, mas são persistentes e não desaparecem
depois que o comando executa. Eles permitem que processos
escrevam e leiam dados de forma assíncrona, facilitando a
comunicação em ambientes de tempo real (Machado; Maia, 2013).
A criação de FIFOs pode ser feita através do comando mkfifo, por
exemplo: mkfifo /tmp/minha_fifo, criando um canal que pode ser
usado por múltiplos processos para troca de dados.
Além disso, o uso de memórias compartilhadas é outra técnica
importante. Em sistemas Unix-like, a memória compartilhada
pode ser implementada utilizando o sistema de memória virtual.
Processos podem ler e escrever em uma região específica da
memória, facilitando o compartilhamento de dados entre eles.
Isso é especialmente útil em cenários nos quais dados complexos
precisam ser acessados por vários processos de maneira eficiente,
sem que seja necessário usar arquivos temporários ou manipular
sistemas de arquivos.

A semaforização também é usada para controlar o acesso

concorrente a recursos compartilhados entre processos. A
semaforização permite que processos sincronizem suas atividades
para evitar conflitos quando vários processos acessam o mesmo
recurso simultaneamente (Silva; Borges, 2024). Sistemas Unix-like
oferecem diversas ferramentas e bibliotecas, como semaphore.h,
que facilitam a implementação de mecanismos de sincronização
entre processos.

Por fim, é importante mencionar a sinalização como um método

fundamental de comunicação. Nos sistemas Unix-like, os sinais
são usados para notificar processos sobre eventos, como falhas,
alterações em estados de execução ou interrupções temporárias.
Eles permitem que um processo envie um aviso para outro,
informando sobre algum evento que requer resposta ou que afeta
o comportamento do processo receptor.

Em resumo, a comunicação entre processos em sistemas

operacionais que não são Windows depende de uma combinação
de métodos, como pipes, FIFO, memória compartilhada,
semaforização e sinalização. Esses métodos oferecem
flexibilidade e controle sobre a troca de informações entre
processos, permitindo a criação de sistemas robustos e eficientes
que operam sem a necessidade de sistemas operacionais
complexos como o Windows. A profundidade dessas técnicas
exige que os administradores e desenvolvedores tenham um bom
conhecimento das ferramentas e comandos disponíveis no
sistema operacional em uso, seja para gerenciamento ou para o
desenvolvimento de software em ambientes Unix-like.

Vamos Exercitar?
Gerenciamento de tarefas no Windows em
um sistema com baixo desempenho
Descrição da situação-problema

Em uma empresa, os usuários estão reclamando de uma

diminuição significativa no desempenho de suas máquinas
Windows. Os sistemas estão começando a travar, com aplicativos
demorando para responder e uma alta carga de CPU sendo
observada, mesmo quando os usuários não estão executando
tarefas exigentes. O gerenciador de tarefas do Windows foi
aberto, e notou-se que alguns processos estavam consumindo
excessivos recursos do sistema.

A equipe de TI foi chamada para investigar o problema e

encontrar uma solução, já que o desempenho do sistema estava
afetando a produtividade dos usuários.

Problemas identificados:

1. Alto consumo de CPU: alguns processos estavam utilizando

uma quantidade excessiva de CPU, o que causava lentidão no
sistema.
2. Processos desnecessários em execução: diversos processos
em segundo plano não estavam sendo gerenciados
adequadamente, como aplicativos de inicialização, os quais
consumiam recursos desnecessariamente.
3. Vírus ou malware: há suspeita de que algum malware ou
vírus pudesse estar consumindo recursos ou executando
 processos ocultos no sistema.

Qual solução você apresentaria para essa situação problema?

Resolução da situação-problema

O gerenciador de tarefas do Windows é uma ferramenta poderosa

para monitorar e gerenciar processos, especialmente quando o
sistema está enfrentando problemas de desempenho. No caso
descrito, ele foi fundamental para identificar e eliminar um
malware que estava consumindo recursos excessivos, além de
permitir a otimização da inicialização do sistema. A prática de
monitorar regularmente o uso de recursos e os processos em
execução pode ajudar a manter o sistema operacional eficiente,
seguro e funcionando corretamente.

A equipe de TI seguiu estes passos, utilizando o gerenciador de

tarefas do Windows e ferramentas complementares para
gerenciar e otimizar os recursos do sistema:

Passo 1: identificação de processos problemáticos

1. Abrir o gerenciador de tarefas: a equipe de TI abriu o

gerenciador de tarefas pressionando Ctrl + Shift + Esc para
acessar uma visão geral de todos os processos em execução.
2. Análise da aba "Processos": na aba "Processos", foi possível
visualizar quais processos estavam utilizando a maior parte
da CPU e da memória. Identificou-se que o processo
"[Link]" estava consumindo mais recursos do que o
normal, além de um processo desconhecido chamado
"[Link]", que parecia não ter relação com o sistema
operacional ou programas comuns.
3. Análise do desempenho: na aba "Desempenho", foi possível
verificar o uso do processador, memória e disco,
evidenciando que o uso da CPU estava constantemente em
níveis altos, o que indicava uma sobrecarga.
Passo 2: verificação de processos suspeitos e malware

1. Análise do processo suspeito: o processo "[Link]" foi

identificado como uma possível ameaça. Usando o Windows
Defender e ferramentas de terceiros, como o Malwarebytes,
foi realizado um exame completo do sistema, detectando que
o arquivo era um tipo de malware disfarçado.
2. Encerramento de processos não essenciais: o gerenciador
de tarefas foi usado para finalizar o processo malicioso
"[Link]" e outros processos não essenciais que estavam
sendo executados sem necessidade, liberando recursos para
o sistema.

Passo 3: otimização e limpeza de inicialização

1. Desabilitar programas de inicialização desnecessários: na

aba "Inicializar" do gerenciador de tarefas, foram
desabilitados diversos programas que iniciavam
automaticamente com o Windows e não eram necessários
para o funcionamento diário. Isso reduziu o consumo de
memória e CPU logo após a inicialização do sistema,
melhorando o tempo de resposta.
2. Verificação de atualizações e drivers: a equipe de TI
também verificou se havia atualizações pendentes do
sistema ou drivers desatualizados, especialmente para os
controladores de dispositivos de hardware. Isso garantiu que
o sistema estivesse otimizado e livre de falhas conhecidas
que poderiam impactar o desempenho.

Passo 4: monitoramento continuado e melhoria

1. Reinicialização e teste de desempenho: após a remoção do

malware e a desativação dos programas de inicialização
desnecessários, o sistema foi reiniciado e o gerenciador de
tarefas foi reaberto para verificar se os recursos estavam
sendo utilizados de maneira adequada. O desempenho da
 CPU e da memória melhorou significativamente, e os
processos agora estavam dentro de parâmetros normais.
2. Uso do monitor de recursos: a equipe recomendou o uso do
monitor de recursos (acessível a partir do gerenciador de
tarefas, na aba "Desempenho"), para monitoramento contínuo
da utilização dos recursos e identificação de eventuais
problemas no futuro antes que afetassem o desempenho.

Treinamento para usuários: os usuários receberam orientações

sobre como identificar e lidar com processos de alto consumo e
como usar o gerenciador de tarefas para encerrar processos
problemáticos de forma segura.

Saiba Mais
Para conhecer mais sobre gerência de processo em sistemas
operacionais, leia o artigo Gerência de Processos em Sistemas
Operacionais Distribuídos.

Referências Bibliográficas
ALVES, W. P. Sistemas Operacionais. 9. ed. São Paulo: Érica, 2014.

CÓRDOVA JR., R. S.; LEDUR, C. L.; MORAIS, I. S. Sistemas

Operacionais. Porto Alegre: SAGAH, 2019.

FENERICH, F. C. Administração dos sistemas de operações.

Curitiba: Intersaberes, 2016.

MACHADO, F. B.; MAIA, L. P. Arquitetura de Sistemas

Operacionais. 5. ed. Rio de Janeiro: Grupo GEN, 2013.

OLIVEIRA, R. S.; CARISSIMI, A. da S.; TOSCANI, S. S. Sistemas

Operacionais. 4. ed. Porto Alegre: Bookman, 2009.

SILBERSCHATZ, A.; GALVIN, P. B.; GAGNE, G. Fundamentos de

Sistemas Operacionais. 9. ed. Rio de Janeiro: LTC, 2015.
SILVA, G. P. da; BORGES, J. A. dos S. Arquitetura e Organização
de Computadores: uma introdução. Rio de Janeiro: LTC, 2024.

TANENBAUM, A. S. Sistemas operacionais modernos. 2. ed. São

Paulo: Pearson, 2005.

Encerramento da Unidade

PROCESSOS E THREADS

Videoaula de Encerramento
Olá, estudante! Nesta videoaula, revisaremos os conceitos de
processos e threads em sistemas operacionais, os quais foram
estudados nesta unidade e são fundamentais para compreender a
estrutura e o gerenciamento de tarefas nessas plataformas.
Ambos desempenham papéis cruciais para garantir eficiência e
organização na execução de programas.

Os processos são unidades independentes de execução, cada

qual com seu próprio espaço de memória e recursos dedicados,
como alocação de CPU, memória e dispositivos de entrada e
saída. Essa independência entre os processos proporciona
isolamento e segurança, pois evita que erros em um processo
afetem diretamente outro. No entanto, isso torna a comunicação
entre processos mais desafiadora, exigindo o uso de métodos
específicos, como pipes, memória compartilhada ou filas de
mensagens.

Por outro lado, as threads são as menores unidades de execução

dentro de um processo. Elas compartilham o mesmo espaço de
memória e os recursos do processo pai, o que possibilita uma
comunicação mais rápida e eficiente entre elas. Entretanto, essa
interdependência implica riscos, já que falhas em uma thread
podem comprometer o funcionamento de todo o processo. As
threads são amplamente empregadas para realizar tarefas
simultâneas dentro de um mesmo processo, melhorando o
desempenho e a capacidade de resposta do sistema.

O domínio desses conceitos é vital para o exercício profissional. A

compreensão de processos e threads impacta diretamente a
eficiência, a escalabilidade e a segurança dos sistemas.
Profissionais que lidam com administração de sistemas ou
desenvolvimento de software precisam utilizar esses
conhecimentos para otimizar recursos, solucionar problemas e
projetar soluções robustas e escaláveis, atendendo às
necessidades dos usuários e das organizações.

Estudar e aprofundar-se nesses temas é essencial, pois eles

formam a base de muitas tecnologias que utilizamos diariamente.
Continue explorando e aplicando esses conceitos para se tornar
ainda mais competente em sua área!

Prepare-se para essa jornada de conhecimento! Vamos lá!

Ponto de Chegada
Olá, estudante! Para desenvolver a competência desta unidade,
que é compreender a funcionalidade de processos e threads na
estrutura de um sistema operacional.

Os processos e as threads são componentes essenciais para o

funcionamento de um sistema operacional moderno. Ambos têm
papéis distintos, mas complementares, quando se trata de
gerenciar a execução de programas e tarefas no computador.

Processos em sistemas operacionais

Um processo é uma instância de execução de um programa. Ele
consiste em um conjunto de atividades que o sistema operacional
gerencia para garantir que o programa seja executado de forma
ordenada e eficiente (Fenerich, 2016). Cada processo é isolado e
possui seu próprio espaço de memória, o que impede que um
processo afete diretamente outro. O sistema operacional aloca
recursos (CPU, memória, I/O etc.) para cada processo, e o
processo tem um ciclo de vida que inclui criação, execução,
espera e término.

Função dos processos:

Isolamento e segurança: cada processo é isolado, o que

significa que ele não pode acessar diretamente a memória ou
os recursos de outro processo sem permissões específicas.
Gerenciamento de recursos: o sistema operacional aloca e
monitora recursos (como CPU, memória, espaço de disco)
para garantir que os processos sejam executados de maneira
eficiente e sem conflitos.
Ciclo de vida do processo: o processo passa por várias fases
durante sua execução, como criação, execução, bloqueio e
finalização.
 Controle de estado: o sistema operacional mantém o
controle sobre o estado dos processos, como pronto, em
execução, esperando ou terminado. O escalonador decide
qual processo será executado em dado momento, levando
em consideração diversos parâmetros, como prioridade,
tempo de execução e recursos necessários.

Threads em sistemas operacionais

Uma thread, conhecida também como linha de execução,

representa a menor unidade de processamento em um sistema.
Dentro de um processo, é possível haver uma ou várias threads,
sendo que cada uma desempenha uma função específica na
execução do processo. As threads compartilham o mesmo espaço
de memória e os recursos alocados pelo processo pai, o que
facilita a comunicação e a sincronização entre elas de forma
eficiente (Silberschatz; Galvin; Gagne, 2015).

Função das threads:

Execução simultânea: threads pertencentes ao mesmo

processo podem operar ao mesmo tempo, especialmente em
sistemas com CPUs multicore. Isso possibilita que múltiplas
tarefas sejam realizadas paralelamente dentro de uma única
aplicação.
Uso compartilhado de recursos: as threads de um processo
utilizam o mesmo espaço de memória e recursos globais, o
que simplifica a comunicação entre elas. Contudo, isso
demanda que o sistema operacional implemente ferramentas
de sincronização para prevenir conflitos e problemas
decorrentes do acesso simultâneo, conforme observado por
Oliveira, Carissimi e Toscani (2009).
Eficiência operacional: a criação e a gestão de threads
apresentam menor custo computacional em comparação à
criação de novos processos. Isso ocorre porque as threads
 aproveitam os recursos já alocados pelo processo pai, como
memória e variáveis globais, evitando a redundância de
alocação de recursos (Alves, 2014).
Concorrência e controle: apesar do compartilhamento de
recursos, é fundamental que o sistema operacional
administre cuidadosamente a sincronização entre as threads.
Isso garante a integridade das operações, evita condições de
corrida e assegura a execução ordenada de tarefas críticas.

Como o sistema operacional gerencia processos e

threads

Os sistemas operacionais são responsáveis por gerenciar

processos e threads, elementos essenciais para o funcionamento
das aplicações modernas. A gestão eficiente desses componentes
garante o uso ideal dos recursos de hardware e a execução
estável de múltiplas tarefas simultaneamente. A seguir,
revisaremos os principais aspectos desse gerenciamento.

Gerenciamento de processos

Os processos são unidades independentes de execução que

possuem seu próprio espaço de memória e recursos. O sistema
operacional gerencia os processos em várias etapas:

Criação e finalização de processos: o sistema operacional

controla a criação de novos processos, atribuindo a eles os
recursos necessários, como memória, CPU e dispositivos de
entrada/saída (Machado; Maia, 2013). Quando um processo
termina, o sistema libera os recursos alocados para serem
reutilizados.
Estados dos processos: cada processo pode estar em
diferentes estados, como pronto, em execução ou em espera.
O sistema operacional monitora essas transições e mantém
 tabelas de processos para rastrear o status de cada um
(Machado; Maia, 2013).
Escalonamento: para determinar qual processo será
executado em um dado momento, o sistema utiliza
algoritmos de escalonamento. Métodos, como Round-Robin,
Prioridade e First Come, First Served (FCFS), são usados para
alocar tempo de CPU de forma justa e eficiente (Silva;
Borges, 2024).
Comunicação entre processos (IPC): processos distintos
podem precisar trocar informações. O sistema operacional
fornece mecanismos, como pipes, memória compartilhada e
filas de mensagens, para facilitar essa comunicação.

Gerenciamento de threads

Quando um processo é composto por múltiplas threads, o sistema

operacional desempenha um papel crucial no gerenciamento
dessas linhas de execução. Ele aloca recursos, decide a ordem de
execução e garante que threads de um mesmo processo não
interfiram umas nas outras de forma negativa (Fenerich, 2016).

Em sistemas com múltiplos núcleos de CPU, as threads podem ser

distribuídas entre os núcleos, possibilitando a execução em
paralelo. Isso aumenta significativamente a eficiência e reduz o
tempo de processamento, especialmente em aplicações que
demandam alto desempenho, como renderização gráfica e
simulações científicas.

Sincronização de threads

Para evitar problemas como condições de corrida, o sistema

operacional fornece mecanismos de sincronização, por exemplo:

Mutexes (Mutual Exclusion): garantem que apenas uma

thread acesse um recurso crítico de cada vez (Fenerich,
2016).
 Semáforos: permitem controle sobre múltiplas threads,
estabelecendo limites para acesso simultâneo a recursos
compartilhados.
Barreiras: sincronizam um conjunto de threads, assegurando
que todas atinjam um determinado ponto antes de continuar.

Esses mecanismos são indispensáveis para preservar a

integridade dos dados e garantir que operações críticas sejam
executadas corretamente.

Comunicação entre threads

Dentro de um processo, as threads compartilham o mesmo

espaço de memória, facilitando a troca de informações. Isso
elimina a necessidade de métodos complexos de Inter-Process
Communication (IPC), como pipes ou filas de mensagens, usados
entre processos distintos. No entanto, esse compartilhamento
exige controle rigoroso do sistema operacional para evitar
corrupção de dados em cenários de acesso simultâneo,
especialmente em operações de leitura e escrita (Silva; Borges,
2024).

O escalonamento e o gerenciamento eficiente de processos e

threads são pilares do funcionamento de sistemas operacionais
modernos. Eles garantem não apenas a distribuição otimizada de
recursos, mas também a sincronização e a comunicação seguras,
essenciais para a estabilidade e o desempenho das aplicações. A
escolha de algoritmos de escalonamento, mecanismos de
sincronização e estratégias de paralelismo deve ser
cuidadosamente ajustada às necessidades específicas do sistema
para maximizar a eficiência e a confiabilidade.

Diferença entre processos e threads

Os processos e threads são conceitos fundamentais no contexto

de sistemas operacionais, ambos representando unidades de
execução, mas com diferenças significativas em relação ao seu
funcionamento, uso e gerenciamento. Exploraremos essas
diferenças de maneira mais detalhada, conforme o quadro a
seguir.

Características Processo Thread

Instância de um A menor unidade de
Definição programa em execução dentro de
execução. um processo.
Compartilha o espaço
Possui seu próprio
Espaço de memória de memória do
espaço de memória.
processo.
Pode conter múltiplos Executa tarefas dentro
Execução
threads. do processo.
Menor overhead, pois
Mais overhead, pois
as threads
Overhead de criação requer alocação de
compartilham
recursos isolados.
recursos.
É isolado e não pode Compartilha memória
acessar diretamente a e recursos com outras
Independência
memória de outros threads no mesmo
processos. processo.
Processos de
Processamento
entrada/saída ou
Exemplo de uso paralelo, como em
cálculos simultâneos
servidores.
em um programa.

Quadro 1 | Diferença entre processos e threads. Fonte: elaborado

pela autora.

Em um sistema operacional, tanto os processos quanto as threads

têm funções importantes, mas são usados de maneiras diferentes
para atender a diferentes requisitos de desempenho, segurança e
eficiência. Enquanto os processos fornecem isolamento e
segurança, as threads permitem um uso mais eficiente de
recursos e maior paralelismo dentro de um programa. A escolha
entre usar processos ou threads depende das necessidades
específicas da aplicação e do sistema em que estão sendo
executados.

Reflita

A diferença entre um processo e um programa é fundamental

para entender como os sistemas operacionais gerenciam a
execução de tarefas. Dessa forma, reflita: qual é a diferença
entre um processo e um programa?

Explorar o uso de múltiplas threads dentro de um processo

pode revelar como esses pequenos processos internos podem
transformar o desempenho e a eficiência de aplicações
modernas. Nesse sentido, quais são as vantagens de usar
múltiplas threads dentro de um processo?

Nesse mesmo sentido, como as threads são usadas em

aplicações modernas, como servidores web ou jogos?

É Hora de Praticar!
Benefícios da migração para nuvem na
TechSolutions
Descrição da situação-problema

Uma empresa desenvolveu uma aplicação que utiliza múltiplas

threads para processar dados em paralelo, melhorando a
velocidade de resposta e eficiência do sistema. No entanto, a
equipe de desenvolvimento percebeu que, em certas situações,
ocorriam conflitos e inconsistências nos dados processados. Esses
problemas estavam relacionados à falta de sincronização
adequada entre as threads, levando a erros de acesso
concorrente.

Reflita

Pergunta: como a equipe pode resolver esses conflitos de forma

eficaz, garantindo que as threads trabalhem de maneira
coordenada e segura, prevenindo problemas como condições de
corrida?

Resolução do estudo de caso

Resolução da situação-problema

Para resolver esses conflitos, a equipe deve implementar

mecanismos de sincronização, como mutexes e semáforos, dentro
do processo. Esses recursos ajudam a garantir que as threads não
acessem recursos compartilhados de maneira simultânea e
conflitante. Adicionalmente, utilizar barreiras pode ajudar as
threads a coordenações complexas ao final de tarefas paralelas. É
essencial que a equipe também teste e ajuste essas
implementações para identificar e corrigir possíveis problemas de
concorrência.

Dê o play!
Assimile

Em um sistema operacional, processos e threads são

fundamentais para a execução de programas e gerenciamento de
tarefas. A figura a seguir mostra os processos e as threads.
 Figura 1 | Processos e threads. Fonte: elaborada pelo autor.

Referências

ALVES, W. P. Sistemas Operacionais. 9. ed. São Paulo: Érica, 2014.

FENERICH, F. C. Administração dos sistemas de operações.

Curitiba: Intersaberes, 2016.

MACHADO, F. B.; MAIA, L. P. Arquitetura de Sistemas

Operacionais. 5. ed. Rio de Janeiro: Grupo GEN, 2013.

OLIVEIRA, R. S.; CARISSIMI, A. da S.; TOSCANI, S. S. Sistemas

Operacionais. 4. ed. Porto Alegre: Bookman, 2009.

SILBERSCHATZ, A.; GALVIN, P. B.; GAGNE, G. Fundamentos de

Sistemas Operacionais. 9. ed. Rio de Janeiro: LTC, 2015.

SILVA, G. P. da; BORGES, J. A. dos S. Arquitetura e Organização

de Computadores: uma introdução. Rio de Janeiro: LTC, 2024.