Unidade 1-1

Processos e Threads
 O que é um Processo

• Um processo é uma atividade (ou tarefa) de um

programa, que contém o código e dados de uma
atividade.

• Essas são: leitura de dados, escrita de dados,

cálculos no processador, comunicação com o
usuário, comunicação com um BD, comunicação
com a rede interna ou externa, entre outras.
 Processos

– Um trecho de código em execução em uma

máquina.
– É a unidade de processamento concorrente que
um processador sob um SO pode processar.
– Identificado pelo seu PID (Process Identifier).
– Unix (anos 70) foi construído para executar
processos.
 Problema com Processos

• Nos anos 80, foi descoberto que a noção

tradicional de um sistema operacional, de um
processo que executa um único fluxo de
execução, era diferente dos requisitos dos
sistemas operacionais distribuídos.

• Solaris (anos 90), originalmente, utiliza processos.

 Problema com Processos

• E também, diferente dos requisitos dos

aplicativos mais sofisticados que utilizam um
único processador, mas que exigem
concorrência de suas atividades internas.
 Problema com Processos

• O processo tradicional torna complicado e

dispendioso o compartilhamento de recursos
entre atividades relacionadas.
 Solução para o Processamento
Concorrente

• Aprimorar a noção de processo, para que ele

pudesse ser associado a múltiplas atividades
internas a ele.
 Surgimento de Threads
• Com o surgimento de processadores de mais
alto desempenho, uma nova unidade de
processamento concorrente pode ser definida
dentro do próprio processo, novos fluxos de
execução e assim pode-se ter múltiplos fluxos
de execução (múltiplas threads) num mesmo
processo.

• Cada fluxo de execução é chamada Thread.

 Threads
• Atualmente, um processo consiste em um
ambiente de execução, contendo uma ou
mais threads.

• Thread: unidade de processamento

concorrente nos sistemas operacionais
atuais.
 Contexto de um Processo
• Um identificador do processo (PID).
• Um segmento de código.
• Um segmento de dados.
• Os valores dos registradores da CPU.
• Um contador de programa lógico.
• Uma pilha de execução.
• O estado do processo.
• Informações para escalonamento (prioridade, tempo)
• Dados para contabilização de uso.
• Recursos alocados: arquivos, portas, eventos, outros.
 Processo
• Um processo é uma entidade a nível de
kernel.

• O único modo para seu programa acessar a

dados na estrutura (contexto) de um processo,
consultar ou mudar seu estado, é via uma
chamada de sistema.
 Contexto de uma Thread
• Um identificador da Thread.
• Um segmento de código.
• Um segmento de dados.
• Os valores dos registradores da CPU.
• O contador de programa.
• Uma pilha de execução.
• O estado da Thread.
• Informações para escalonamento (prioridade, ...)
• Dados para contabilização de uso.
• Recursos alocados: arquivos, portas, eventos, outros.
 Threads

• Definição:
– Threads (linhas de execução) são atividades
(tarefas internas) concorrentes executadas dentro
de um processo.

– Um processo pode ter uma ou mais threads.

 Multithreading

• Múltiplas threads executam

concorrentemente em um processo, e é
análogo a múltiplos processos executando
concorrentemente em um único processador.

• Threads pertencentes a um mesmo processo,

compartilham os mesmos recursos e memória
(espaço de endereçamento) do processo.
 Multithreading

• Suporte a Threads:
– Threads nativas do SO (entidades a nível de kernel).
– Threads como entidades a nível do usuário.

– Suporte de programação multithreading.

Exemplo: JVM do Java

– Linguagem de programação multithreading.

Exemplo: Java
 Três Processos - cada um com
uma Thread
Cada thread tem seu espaço de endereçamento.
Thread

Contador de Programa
Processo
 Um Processo com três Threads
• Todas num mesmo espaço de endereçamento.

Processo

Multiplas Threads
 Processos e Threads

• Um confeiteiro.
• O confeiteiro é o processador.
• Um Livro de Receitas é um processo.
• Uma receita corresponde a uma Thread.
• Fazer um bolo de aniversário.
• Ingredientes: farinha, ovos, açucar, ...
• Os ingredientes são os dados.
 Programa, Processo e Thread

• O processo é a atividade que consiste em

nosso confeiteiro ler a receita (Thread),
buscar os ingredientes (Thread), bater o bolo
(Thread) e cozinhar o mesmo (Thread).
 Alternando para outro processo
• Confeiteiro, Filho do confeiteiro, Abelha

• Ferrada da abelha no filho do confeiteiro.

• Confeiteiro precisa socorrer o filho.

• O confeiterio registra onde estava na receita

(o estado e o contexto do processo são salvos).
 Alternando para outro processo
• Confeiteiro procura um livro de pronto-socorro
(outro processo).

• Segue a orientações do livro.

• O Confeiteiro alterna do processo (Livro de

Receitas pra Fazer o Bolo) para outro, de
prioridade mais alta (Administrar cuidado
Médico), cada um sendo um processo diferente
(receita e livro).
 Processo é uma atividade
• Quando a picada for tratada, o confeiteiro volta a
fazer o seu bolo, continuando do ponto onde
parou, quando abandonou o processo (Fazer o
Bolo).

• A ideia é que processo é um tipo de atividade.

• E em cada atividade para “Fazer o Bolo” ou

“Atendimento Médico” existem outras tarefas:,
que correspondem às Threads.
 Escalonamento de Threads

• Todo SO tem um programa chamado

Scheduler (o escalonador do SO) que
seleciona, num dado instante, uma thread que
deve ser executada pelo processador,
alternando este entre threads.
 Algoritmo de Escalonamento

– Define a ordem de execução de processos/ threads com

base em uma fila ou prioridade da thread.

– Processos/Threads do sistema SO e de aplicações críticas

exigem maior prioridade.

– Em geral, os sistemas operacionais adotam uma política

depara atender a todas os processos/threads de maneira
justa .
 Escalonamento por Time-Slicing
• Fracionamento de tempo do processador.

• Divide o tempo do processador entre threads

de igual prioridade.

• Implementado por um Timer (hardware) o

qual interrompe o processamento
periodicamente, para permitir o scheduler
buscar uma outra thread para executar.
 Escalonamento Time-Slicing

– Por Processo: escalonador aloca tempo para

execução dos processos, os quais definem como
usar este tempo para executar suas threads.
P1 P2 P3
t11 t12 t21 t22 t23 t31 t32
– Por Thread: escalonador aloca tempo e define a
ordem na qual as threads serão executadas.
t11 t31 t21 t32 t23 t12 t22 t16
 Escalonamento Pre-Emptivo

• Baseado nas prioridades dos

processos/threads.

• Deve ser implementado para garantir que um

processo/thread de alta prioridade possa
executar logo que torna-se pronto, mesmo
que signifique suspender a execução de um
processo de mais baixa prioridade.
 Mudança de Contexto
• Processos/Threads escalonadas mudam de contexto.

• O processo/thread em execução é suspenso, e um

outro processo passa a ser executado.

• Ocorre por determinação do escalonador ou

quando o processo/thread que estava sendo
executado é suspenso.

• O contexto do processo/thread suspenso deve ser

salvo para retomar a execução posteriormente.
Ciclo de Vida de um Processo/Thread

Criado

Pronto

Suspenso

Rodando

Morto
 Estados de um Processo/Thread
• Pronto: pronto para ser executado,
mas sem o direito de usar o
processador.

• Rodando: sendo executado pelo processador.

• Suspenso: aguarda operação de I/O, liberação

de um recurso ou fim de tempo de
espera em uma fila.
 Estado Suspenso

• Dormindo – em espera temporizada.

• Bloqueado – aguarda I/O.

• Em Espera - aguarda uma condição ser

satisfeita.
 Mudança de Estado de um Processo

• Processos/Threads trocam de estado de

acordo com o:
– Algoritmo de escalonamento.
– Troca de mensagens entre esses.
– Interrupções de hardware ou software.
 Threads

• Da mesma forma que os processos.

• Cada thread tem seu estado e segue um

ciclo de vida particular.

• A vida da thread depende do seu processo.

 Troca de Contexto

• Quando duas threads de um mesmo processo

se alternam no uso do processador, ocorre
uma troca de contexto parcial.

• Numa troca parcial, o contador de programa,

os registradores e a pilha devem ser salvos.
 Troca de Contexto

• Uma troca de contexto parcial é mais rápida

que uma troca de contexto entre processos.

• Uma troca de contexto completa é necessária

quando uma thread de um processo que não
estava em execução assume o processador.
 Processos x Threads
• Troca de Contexto: Completa | Parcial

• Comunicação: Inter-Processo | Inter-Threads

• Suporte em S.O.’s:
Quase todos | Os mais atuais

• Suporte em Linguagem de Programação:

Quase todas | As mais recentes