Sistemas Operativos 
Apontamentos sobre Processos e Threads 
Cap. 3 - Processos: 
O que é um processo ? 
Um processo é com...
Possiveis Estados de um Processo: 
• New: O processo está no estágio de criação; 
• Ready: O processo tem agora disponivel...
Como é que um processo passa de inactivo a activo? 
Tipicamente, o OS vai à tabela de processos, obtém os dados acerca des...
Modo User e Kernel : 
Tipicamente, um programa não pode executar qualquer tipo de instrução que o CPU fornece 
como sendo ...
Controlo sobre Processos: 
Os sistemas baseados em Unix fornecem um conjunto de system calls para poder manipular 
process...
Um processo (parent) cria um novo processo (child) através da função fork. 
#include <sys/types.h> 
#include <unistd.h> 
p...
Context Switches: 
O kernel do sistema operativo implementa o mecanismos de multitasking como uma forma 
de controlo de ex...
Carregar e Executar Programas: 
A função execve carrega e executa um novo programa no contexto do processo currente. 
#inc...
Threads: 
Threads são a virtualização do CPU. Consistem num identificador (thread ID), um Program 
Counter, uma Stack, e u...
Vejamos o exemplo de um Web Server: 
Ao usarmos o mecanismo de multi-threading na implementação de um web-server estamos a...
Modos de MultiThreading: 
Threads podem ser incluidas em um de dois modos: 
• Kernel Mode 
• User Mode 
Em implementações ...
Modo Um-para-Um: 
Como o nome indica, este modelo cria uma kernel-thread para cada user-thread. 
Neste modelo não existem ...
Bibliotecas de criação de Threads: 
Tipicamente, cada linguagem de programação ou uma framework, fornece uma API especific...
Win32 Threads: 
Muito parecidas com as pThreads, porém, como todas as criações da microsoft, a 
nomemclatura é a maior dif...
Sistemas Operativos - Processos e Threads
Próximos SlideShares
Carregando em…5
×

Sistemas Operativos - Processos e Threads

597 visualizações

Publicada em

Apontamentos pessoais acerca de sistemas operativos, mais concretamente, acerca de Processos e Threads.

Erros ortográficos existentes, pelo que se sugere que se ignorem os mesmos.

Publicada em: Educação
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
597
No SlideShare
0
A partir de incorporações
0
Número de incorporações
3
Ações
Compartilhamentos
0
Downloads
21
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Sistemas Operativos - Processos e Threads

  1. 1. Sistemas Operativos Apontamentos sobre Processos e Threads Cap. 3 - Processos: O que é um processo ? Um processo é como que um contentor/ambiente onde existe um conjunto de recursos que são usados por parte do programa a ser execudado dentro do ambiente. Fornece a noção de que o programa é a unica execução activa e tem todo o acesso aos recursos do computador. O principal recurso de um processo é o espaço de endereçamento virtual. O que identifica um processo ? Um processo pode ser identificado por diversos parâmetros, entre eles os seguintes: • Identificador: Um identificador único associado ao processo de forma a poder distinguir dos restantes. • Estado: Estado actual depende de certos factores. • Prioridade: Nivel de prioridade relativamente a outros processos. • Program Counter: O endereço da próxima instrucção a ser executada no programa. • Ponteiros para Memória: Inclui ponteiros para o código do programa e dados associados ao programa. • Dados de Contexto: Dados presentes nos registos do CPU enquano o processo está a ser executado.
  2. 2. Possiveis Estados de um Processo: • New: O processo está no estágio de criação; • Ready: O processo tem agora disponivel todos os recursos de que necessita para ser executado, porém o CPU não está a executar as instrucções que este processo contém; • Running: The CPU está a executar as instrucções que este processo contém; • Waiting: O processo não pode continuar a ser executado devido a estar à espera de algum recurso ou que algum event ocorra. • Terminated: O processo foi executado por completo; Illustration 1: Diversos estados de um processo; Representação de um Processo em Linux: Tipicamente, a estrutura que representa um processo em linux é a struct task_struct. Esta estrutura contém toda a informação necessária para representar um processo. Struct task_struct{ pid_t pid; //process identifier long state; //state of the process unsigned int time_slice; //scheduling information struct task_struct *parent; //this process's parent struct list_head children; //this process's children struct files_struct *files; //list of open files struct mm_struct *mm; //address space of this process } Estes dados são guardados acerca de cada processo criado, e assim, é possivel interromper o fluxo de execução, realizar outro tipo de trabalho e retomar o trabalho neste processo anterior pois todos os dados do contexto actual foram guardados numa estrutura de dados. Tipicamente, tem o nome de Process Control Block.
  3. 3. Como é que um processo passa de inactivo a activo? Tipicamente, o OS vai à tabela de processos, obtém os dados acerca desse mesmo e carrega nos registos do CPU os dados relativos ao seu contexto armazenado, nomeadamente, o Program Counter e os dados associados ao código do programa. Acções necessárias para 'matar' um processo: • Terá de terminar todas as threads activas; • Libertar a memória usada para definir o espaço de endereçamento; Pros e Contras da existência de Processos: O modelo que especifica trocas de informação entre processos é muito simples: File Tables são partilhadas e espaços de endereçamento não são. Esta separação dos espaços de endereçamento tem vantagens e desvantagens. Desde logo, é evidente que um processo não pode escrever noutro espaço de endereços que não seja o seu, o que elimina diversos problemas. Por outro lado, processos com espaço de endereços diferente dificulta a comunicação entre eles. Para que esta comunicação seja estabelecida, tem de ser feita através de mecanismos IPC (inter-process comunication). O próprio controlo via tabelas de processos e este uso de IPC's causa um grande overhead. Espaço Privado de Endereços: Um processo fornece a cada programa a ilusão de que tem acesso exclusivo ao espaço de endereços do sistema. Numa máquina com endereços de n-bit, o espaço de endereços é um conjunto possivel de 2n. Este espaço é privado na medida em que um qualquer endereço pertencente a esse mesmo espaço não pode ser lido ou escrito por outros processos. A parte mais no topo, Kernel Virtual Memory contém os dados, stack e código que é executado por parte parte do Kernel em nome do processo.Tipicamente, acontece quando são utilizadas System Calls por parte do programa. Illustration 2: Mapa de espaços de endereços fornecido a um qualquer processo;
  4. 4. Modo User e Kernel : Tipicamente, um programa não pode executar qualquer tipo de instrução que o CPU fornece como sendo o seu instruction set. O processador fornece, portanto, um mecanismo que restringe o acesso que um programa tem relativamente ao conjunto de instruções, bem como regiões do espaço de endereçamento. Por programa, está implicito processo. Tipicamente, exite um controlo através de um mode bit presente num registo de controlo que caracteriza os privilégios que o processo poderá ter relativamente ao sistema. Quando o mode bit está activo, o processo está a correr em Kernel Mode. Este é o modo mais previligiado. O processo pode "executar" qualquer instrucção do instruction set e aceder a qualquer região do espaço de endereçamento. Por outro lado, quando o mode bit não está activo, o processo está a correr em user mode. Neste modo, o processo não tem total acesso como em kernel mode. Por omissão, um processo começa por estar em modo user. A única maneira de obter uma mudança para kernel mode é através uma exception. Exception: • Interrupt: • Traps: • Fault: Quando a exception acontece, o controlo passa para o exception handler, e isso muda automáticamente o modo associado com o processo porque o handler corre em kernel mode. Após isso, quando o controlo é devolvido, o processo volta a obter o modo de user.
  5. 5. Controlo sobre Processos: Os sistemas baseados em Unix fornecem um conjunto de system calls para poder manipular processos dentro de programas em linguagem C. Obter ID's de processos: Cada processo, como pudemos ver anteriormente (task_struct), contém um identificador positivo. A system call getpid retorna o id do processo que invocou a chamada. #include <sys/types.h> #include <unistd.h> //é a mesma coisa que retornar int pid_t getpid(void); pid_t getppid(void); Returns: PID of either the caller or the parent Criar e Terminar Processos: Do ponto de vista do programador, podemos pensar num processo como estado num de três estados: • Running: O processo está em execução por parte do CPU ou está à espera de ser executado. • Stopped: A execução do processo está suspensa e não será 'scheduled'/agendado. Um processo pára quando recebe um dos seguintes sinais – SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU – e permanece parado até receber o sinal SIGCONT, a partir do qual pode ser de novo executado. • Terminated: O processo está parado permanentemente. Pode acontecer por uma de três razões: 1. Recebeu um sinal que tem como intenção terminar o processo. 2. Retornou a partir da rotina main. 3. Invocou a função exit. #include <stdlib.h> void exit(int status); This function does not return
  6. 6. Um processo (parent) cria um novo processo (child) através da função fork. #include <sys/types.h> #include <unistd.h> pid_t fork(void); Returns: 0 to child, PID of child to parent, −1 on error O processo filho é muito parecido com o processo parent. O child recebe uma cópia (mas é algo separado) do espaço de endereçamento vindo do parent. O child também recebe uma cópia da File Table, ou seja, também tem acesso e privilégios para ler e escrever sobre os ficheiros que o processo parent tinha acesso. A principal diferença está no identificador PID. A função fork é chamada uma vez e retorna duas vezes. Um retorno é para o processo parent e devolve o PID do processo child. O segundo retorno é para o processo child e devolve 0. #include "csapp.h" int main(){ pid_t pid; nt x = 1; pid = Fork(); if (pid == 0) { /* Child */ printf("child : x=%dn", ++x); exit(0); } /* Parent */ printf("parent: x=%dn", --x); exit(0); } Ambos os processos fazem print no stdout porque tanto o processo child como o parent têm acesso aos ficheiros abertos, pelo que têm acesso ao stdout.
  7. 7. Context Switches: O kernel do sistema operativo implementa o mecanismos de multitasking como uma forma de controlo de exceptions de alto nivel – Context Switch. O kernel mantém um context para cada processo. O contexto é o estado do processo (o que o caracteriza num determinado momento) que o kernel necessita de saber/armazenar de forma a resumir um processo interrompido anteriormente. Tipicamente, o contexto contém o ultimo valor obtido por parte do program counter, a parte activa da stack (user mode), a stack do kernel, entre outros. É também preciso restaurar estruturas de dados presentes na região do kernel, como por exemplo: • Page Table - que caracteriza o espaço de endereçamento; • Process Table – contém informação acerca do processo currente; • File Table – contém informação acerca de ficheiros que o processo acedeu; Durante a execução de um processo, o kernel pode decidir interromper o processo actualmente em execução e resumir um processo anteriormente interrompido – scheduling – e é controlado por um pedaço de código pertencente à região do kernel chamadao de scheduler. Como funciona o processo de context-switch: 1. Armazena o estado do processo actualmente em execução; 2. Restaura o estado previamente armazenado relativamente a um processo interrompido anteriormente; 3. Passa o controlo para o processo que acabou de ser restaurado; Illustration 3: Exemplo de mudança de contexto;
  8. 8. Carregar e Executar Programas: A função execve carrega e executa um novo programa no contexto do processo currente. #include <unistd.h> int execve(const char *filename, const char *argv[], const char *envp[]); Does not return if OK, returns −1 on error A função execve carrega e executa uma imagem executável passado por filename. A função só apresenta retorno caso seja encontrada uma excepção. A lista de argumentos dada por argv e é representada por um array de ponteiros com cada indice a apontar para um dos argumentos. Importante: Após o execve carregar a imagem executável , invoca o código nativo de start. Esse código _start inicia a stack e passa controlo para a rotina main. Tipica Organização da User Stack:
  9. 9. Threads: Threads são a virtualização do CPU. Consistem num identificador (thread ID), um Program Counter, uma Stack, e um restante conjunto de registos. Processos MultiThread consistem em ter várias threads, vários fluxos de execução de um programa dentro de um mesmo processo. Essas threads têm acesso, em simultaneo, ao código do programa, aos dados por ele necessários e os ficheiros aos quais ele tem acesso. Em termos de registos e de stack, cada thread tem os seus. O porquê de usarmos Threads: • Muito úteis, na medida em que, um programa pode processar tarefas em simultâneo que de outra forma teriam de ser de forma sequencial, forma essa que acarreta com os seus devidos problemas. • Um exemplo muito usual é o uso de threads num programa de editor de texto. Enquanto uma thread executa a tarefa de verificar erros ortográficos, outra thread poderá estar a carregar imagens do disco para o documento, e outro ainda poderá estar a criar backups do ficheiro de tempos a tempos.
  10. 10. Vejamos o exemplo de um Web Server: Ao usarmos o mecanismo de multi-threading na implementação de um web-server estamos a permitir que ele possa responder a vários requests em simultâneo. De outra forma, todas as respostas teriam de ser dadas de forma sequêncial, ou pior, teriamos de multiplicar os processos associados ao programa – causaria um grande overhead - o que faria com que o programa fosse mais lento, tivesse um maior tempo de resposta associado a si. Tudo isto leva a um fraco desempenho. Beneficios de Utilizar Threads: • Melhor Resposta: Por exemplo, uma thread poderá ser responsável por dar uma resposta rápida a requests recebidos, enquanto outras executam por detrás de si, várias tarefas de cálculos exaustivos. • Partilha de Recursos: Por omissão, threads partilham código do programa, dados associdos a este e outros recursos, que desta forma possibilitam que threads sejam executadas dentro do mesmo espaço de endereçamento. • Economia de Recursos: Criar e gerir threads (context-switch) é muito mais rápido e barato do que implementar um programa que utilize replicação de processos. • Programa Escaláveis (Scalability): Utilização de arquitecturas multiprocessador permite que um processo possa distribuir diversas tarefas do seu programa por tantas threads activas quantos processadores existirem.
  11. 11. Modos de MultiThreading: Threads podem ser incluidas em um de dois modos: • Kernel Mode • User Mode Em implementações especificas, sejam de S.O. ou máquinas virtuais, tem de existir uma politica de mapeamento em torno de user threads e kernel threads. Modo Muitos-para-Um: Neste modo, muitas user-thread são mapeadas a uma única kernel-thread. A principal dificuldade que este modelo tem é o facto de que, se for recebido um system call que bloquei um determinada thread, todo o processo irá ter bloqueado, mesmo que outras threads tenham a possiblidade de continuar a executar a sua tarefa. Outra particularidade deste modelo é, como uma kernel-thread pode operar apenas num único CPU, este modelo não permite que um processo possa ser distribuido por multiplos CPU's.
  12. 12. Modo Um-para-Um: Como o nome indica, este modelo cria uma kernel-thread para cada user-thread. Neste modelo não existem os problema apresentados no modelo anterior, por razões óbvias. O grande problema deste modelo é o facto de que, como é criada uma kernel-thread para cada user-thread, vai acabar por existir um grande overhead devido à criação e manuntenção de tantas threads. O desempenho do sistema tende a diminuir com o aumento da criação de threads. Tipicamente, sistemas que implementam este modelo também explicitam o número máximo de threads criadas. Modo Muito-para-Muitos: Este modelo implementa um combinação de várias user-threads com a mesma, ou menor, quantidade de kernel-threads. Não existe limite de criação de threads. Processos não ficam bloqueados quando uma das threads recebe um system call de bloqueio, e é possivel distribuir processos por vários CPU's.
  13. 13. Bibliotecas de criação de Threads: Tipicamente, cada linguagem de programação ou uma framework, fornece uma API especifica que ajuda programadores na criação de threads e na sua manuntenção. Três das mais conhecidas são: 1. Pthreads – Biblioteca que pode ser encontrada, por exemplo, na linguagem C; 2. Win32 Threads – Fornecidas com sistemas Windows ao nivel do kernel. 3. Java Threads – Como a linguagem Java corre sobre uma VM, tipicamente, a biblioteca de threads depende do S.O. e do hardware disponível. Pthreads – Principais caracteristicas: • Variáveis globais são partilhadas por todas as threads; • Uma thread pode esperar que outras se juntem a si antes de continuar com a execução da sua tarefa; • pThreas começam a sua execução numa função especificada (no exemplo, função runner); Criação de pThreads: Header necessário: #include <pthread.h> Criação e 'wait' de pThreads: main() { pthread_t thread1, thread2; char *message1 = "Thread 1"; char *message2 = "Thread 2"; int iret1, iret2; /* Create independent threads each of which will execute function */ iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1); iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2); /* Wait till threads are complete before main continues. Unless we */ /* wait we run the risk of executing an exit which will terminate */ /* the process and all threads before the threads have completed. */ pthread_join( thread1, NULL); pthread_join( thread2, NULL); printf("Thread 1 returns: %dn",iret1); printf("Thread 2 returns: %dn",iret2); exit(0); }
  14. 14. Win32 Threads: Muito parecidas com as pThreads, porém, como todas as criações da microsoft, a nomemclatura é a maior diferença. Java Threads: Em Java, todos os programas usam threads. Mesmo até um programa como 'Hello World' – Main Thread. O processo de criação de threads necessita de iniciar com um objecto que implemente a interface Runnable ou que uma class extends a class Thread. Desta forma, estará disponivel o hook method run que deve ser re-escrito de forma a fornecer funcionalidades à thread. Criar um objecto Thread não faz com que a mesma seja executada. Uma thread é executada quando o método start é invocado. Este aloca toda a memória necessária e invoca o método run. Em Java não existe o conceito de variáveis globais pelo que uma thread recebe, muitas vezes como parâmetro, objecto que será 'partilhado'. public static void main(String[] args){ .... Sum sumObject = new Sum(); Thread thr = new Thread(new ImplementsRunn(sumObject)); thr.start(); try{ thr.join(); System.out.print("The sum is"+ sumObject.getSum()); }catch(Exc.. e){ .... } } Cancelamento de Threads: Tipicamente, threads podem ser canceladas de duas maneiras: • Asynchronous Cancellation : A thread é cancelada imediatamente; • Deferred Cancelation: Activa uma flag que indica à thread que esta deve-se cancelar quando for conveniente. A flag que será cancelada terá de especificar como lidar com o sinal. Cancelamente em AC pode ser prejudicial para dados partilhados e recursos alocados.

×