Sistemas Operacionais II

Transcrição

1 Mecanismos de sincronização de processos Instituto de Informátic ca - UFRGS Sistemas Operacionais II Da teoria à prática... (Processos, threads, mutex, semáforos, variáveis de condição e monitores) Aula 08 UNIX Posix Threads Java Semáforos Sim Não* Não Mutex (lock/unlock) Não Sim Não Variáveis de condição Não Não Sim Monitores Não Sim Não** * Não fazem parte da especificação POSIX Threads (norma POSIX c), mas é possível empregar os semáforos Unix (norma POSIX b) ** Possui uma variável de condição implícita por método declarado como syncronized Sistemas Operacionais II 2 Semáforos Unix API para semáforos unnamed Existem dois tipos: unnamed e named Unnamed: existe no espaço de endereçamento de UM processo Se usado para sincronizar! Threads: semáforo deve ser declarado como variável global! Processos: explicitar compartilhamento via! Mecanismos de memória compartilhada! Objeto compartilhado Unix! Existem apenas enquanto os processos executam Named: existe no sistema de arquivos, i.é, é um descritor de arquivo Threads e processos usam da mesma forma Uso similar ao de um arquivo São persistentes (existem até o shutdown do sistema) #include <semaphore.h> int sem_init (sem_t * sem, int pshared, unsigned int value); - sem: variável do tipo semáforo - pshared: visibilidade intra processo ( = 0) ou inter processos ( 0) - value: valor inicial do semáforo int sem_wait (sem_t *sem); /* equivalente a primitiva P */ int sem_trywait (sem_t *sem); /* adquire semáforo se livre, caso contrário retorna sem adquirir */ int sem_post(sem_t *sem); /* equivalente a primitiva V */ int sem_destroy(sem_t *sem); /* destruição do semáforo */ Sistemas Operacionais II 3 Sistemas Operacionais II 4

2 API para semáforos unnamed API para semáforos named (sistema de arquivos) Duas formas de explicitar o compartilhamento Memória compartilhada Chamada de sistema semget( ) e associadas Objeto compartilhado POSIX Chamada de sistema shm_open( ) e associadas #include <sys/semaphore.h> sem_t *sem_open (const char *name, int oflag, mode_t mode, int value); - name: caminho de um arquivo (semáforo) - oflag: modo de abertura do semáforo - mode: permissões do arquivo semáforo - value: valor inicial do semáforo int sem_wait (sem_t *sem); /* equivalente a primitiva P */ int sem_trywait (sem_t *sem); /* adquire semáforo se livre, caso contrário retorna sem adquirir */ int sem_post(sem_t *sem); /* equivalente a primitiva V */ int sem_close(sem_t *sem); /* encerra o uso do semáforo */ int sem_unlink(const char *name); /* destruição do semáforo */ Sistemas Operacionais II 5 Sistemas Operacionais II 6 Exemplo de uso semáforo unnamed void *consumidor(void *arg) { int item, out=0; Sincronização com Posix Threads #include <pthread.h> #include <semaphore.h> #include <stdlib.h> #include <stdio.h> #define N 10 #define TRUE 1 int buffer[n]; sem_t vazio, cheio, mutex; void *produtor(void *arg) { int in=0; while(true) { sem_wait(&vazio); sem_wait(&mutex); buffer[in] = rand() in= (in+1) % N; sem_post(&mutex); sem_post(&cheio); while(true) { sem_wait(&cheio); sem_wait(&mutex); item = buffer[out]; out = (out+1) % N; sem_post(&mutex); sem_post(&vazio); int main(int argc, char *argv[ ]) { pthread_t cons, prod; sem_init(&mutex, 0, 1); sem_init(&vazio, 0, N); sem_init(&cheio, 0, 0); pthread_create(&prod, NULL, (void *)produtor, (void *)NULL); pthread_create(&cons, NULL, (void *)consumidor,(void*)null); pthread_join(prod, NULL); pthread_join(cons, NULL); Variáveis do tipo mutex (sincronização de acesso) Variáveis de condição (sincronização de controle) Podem usar semáforos Unix Sistemas Operacionais II 7 Sistemas Operacionais II 8

3 POSIX threads: mutex Primitivas básicas para uso de mutex É um tipo de dados abstrato (pthread_mutex_t) Necessita ser declarado e inicializado Atributos (shared, protocol, ceiling) Duas formas de inicializar (valores default) Via função: pthread_mutex_attr_init (pthread_mutex_attr_t *attr ); Na declaração: pthread_mutex_t attr = PTHREAD_MUTEX_INITIALIZER; Atributos são modificados por funções específicas int pthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr _t* attr ); int pthread_mutexattr_init ( pthread_mutexattr_t *attr ); int pthread_mutex_lock ( pthread_mutex_t t *mutex ); int pthread_mutex_trylock (pthread_mutex_t *mutex ); int pthread_mutex_unlock ( pthread_mutex_t *mutex ); int pthread_mutex_destroy (pthread_mutexattr_t *mutex ); Sistemas Operacionais II 9 Sistemas Operacionais II 10 Exemplo de uso de mutex (POSIX) Variáveis de condição: Posix Threads #include <stdlib.h> #include <pthread.h> # define BUFFER_SIZE 50 int count = 0; int buffer[buffer_size]; pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; void *produtor (void *arg) { int in=0; while( 1 ) { while (count == BUFFER_SIZE) ; pthread_mutex_lock(&m); ++ count; pthread_mutex_unlock(&m); buffer[in] = rand( ); in = (in + 1) % BUFFER_SIZE; void *consumidor (void *arg) { int out=0, item; while( 1 ) { while (count == 0) ; pthread_mutex_lock(&m); -- count; pthread_mutex_unlock(&m); item = buffer[out]; out = (out + 1) % BUFFER_SIZE; int main (int argc, char *argv[]) { pthread_t tprod, tcons; ptread_creat(&tprod, NULL, produtor,(void *)NULL); ptread_creat(&tcons, NULL, consumidor,(void *)NULL); pthread_exit(0); /* Certo ou errado? */ Sistemas Operacionais II 11 Poderoso mecanismo de sincronização Mutex/semáforo binário fazem outras threads esperarem por um recurso Variáveis de condição fazem a própria thread esperar por um estado/evento Servem para sinalizar estados, não para fazer exclusão mútua mutex sincroniza o acesso aos dados, variáveis de condição sincronizam com base no valor dos dados Uso típico é informar o estado de dados compartilhados! ex.: buffer está vazio, buffer está cheio, que evento desejado ocorreu etc. Deve ser sempre usada junto com um mutex Necessário sincronizar o acesso a dado p/ consultar seu valor Uma variável de condição sempre retorna com o mutex locked Sistemas Operacionais II 12

4 Variáveis de condição: comportamento genérico Variáveis de condição no POSIX threads unlock (m) Verdadeiro Processamento lock (m) Condição? Falso [ unlock(m) ] wait [ lock(m) ] Feito automaticamente!! lock(m) Cond=TRUE unlock(m) signal Tipo de dados abstrato (pthread_cond_t) Necessita ser declarado e inicializado Duas formas de inicializar (valores default) Via função: pthread_condattr_init ( pthread_cond_attr_t *cond ); Na declaração: pthread _ cond_ t cond = PTHREAD_COND_INITIALIZER; Mais fácil compreensão e uso que semáforos Espera por um evento: cond_wait Sinalizando a ocorrência de um evento: cond_signal e cond_broadcast! Acorda UMA (cond_signal) ou TODAS (cond_broadcast) threads Importante: as threads não memorizam signal Sempre devem ser usadas em conjunto com um mutex Sistemas Operacionais II 13 Sistemas Operacionais II 14 API POSIX para variáveis de condição Exemplo de variáveis de condição em pthreads int pthread_cond_init ( pthread_cond_t *cond, const pthread_condattr_t *attr ); int pthread_condattr_init( pthread_condattr_t *cond ); Espera por tempo (útil para implementação de time-outs) Código exemplo 1 Produtor-consumidor Código exemplo 2 int t pthread_cond_destroy d d t ( pthread_cond_t d t *cond); int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex ); int pthread_cond_signal ( pthread_cond_t *cond); int pthread_cond_broadcast ( pthread_cond_t *cond ); Códigos fontes disponíves na página da disciplina. Sistemas Operacionais II 15 Sistemas Operacionais II 16

5 Monitores em java Exemplo de monitor Fornece exclusão mútua em um objeto Emprego da palavra-chave synchronized Métodos disponíveis: wait: a thread que executa libera o monitor e fica bloqueada esperando por um signal (notify) notify: acorda uma única thread que está bloqueado na fila de espera notifyall: acorda todos as threads da fila de espera Implementam a semântica signal-and-continue (SC) A variável de condição é implícita por objeto synchronized Class Interfere { private int data = 0 public void update( ) { data++; Seção crítica Class Interfere { private int data = 0 public syncronized void update( ) { data++; Sistemas Operacionais II 17 Sistemas Operacionais II 18 Detalhes de monitores java Leituras adicionais A política da fila é não padronizada Pode variar de uma JVM a outra Como a thread que sinaliza continua a executar (estratégia SC), pode acontecer que a condição sinalizada não seja mais verdadeira Thread que foi acordada para entrar no monitor pode ter que voltar a esperar a condição Permite chamadas aninhadeadlockdas, na forma closed call Cuidado com Códigos-exemplos: Sistemas Operacionais II 19 G. R. Andrews Multithreaded, Parallel and Distributed Programming, Addison Wesley, Capítulo 5 Butenhof, D. Programming with POSIX Threads. Addison-Wesley Prasad, S. Multithreading Programming g Techniques. New York. McGraw-Hill, R. Oliveira, A. Carissimi, S. Toscani Sistemas Operacionais Editora Sagra-Luzzato, Capítulo 4 (seção 4.3) A. Silberchatz, P. Galvin, G. Gagne; Sistemas Operacionais: conceitos e aplicações. (1 a edição). Campus Capítulo 4 (seção 4.5) e capítulo 5 Sistemas Operacionais II 20