Threads

Walfredo Cirne walfredo@dsc.ufcg.edu.br

Memria Compartilhada
Uma questo bsica em computao paralela como as tarefas se comunicam Uma alternativa que as vrias tarefas compartilhem a mesma memria Neste caso, as tarefas podem ser implementadas como processos ou threads

Processos Threads
Processos executam em espao de endereamento prprio, de modo a evitar interferncia de outros processos Threads de um processo usam o mesmo espao de endereamento Threads so mais leves que processos

Alm do que, pode-se criar threads a nvel de usurio (green threads)

Processos
[possvel criao de seg. memria compartilhada] ppid = fork(); if (ppid < 0) { fork_error_function(); } else if (ppid == 0) { child_function(); } else { parent_function(); }

Threads
Threads de um processo usam o mesmo espao de endereamento O programador e a linguagem devem prover proteo contra interferncias Algumas linguagens possuem modelo de concorrncia prprio (ex: ADA e Java) Outras linguagens utilizam extenses para lidar com threads (ex: C tipicamente usa Posix)

POSIX
POSIX: portable operating system interface Objetivo: Portabilidade do cdigo fonte quando servios do sistema operacional se fazem necessrios Padro IEEE

Aplicabilidade de Threads
Threads so muito teis para paralelismo de pequena escala

I/O no blocado Interface com o usurio Construo de servidores

Threads tambm so teis em sistemas de tempo real, onde a concorrncia intrinseca ao problema

Modelo de Programao
Um modelo de programao paralelo deve implementar trs primitivas bsicas

Criao de processos/threads Sincronizao de processos Comunicao entre processos

Em memria compartilhada, a comunicao

feita pela prpria memria

Necessidade de Sincronizao
Por exemplo, considere dois processos atualizando uma varivel comum:

x=x+1 Carregar x em um registro Incrementar registro Armazenar registro em x

Operaes:

C + Posix: Criao de Threads

Criao de thread via:
int pthread_create ( pthread_t *thread_id, const pthread_attr_t *attributes, void *(*thread_function)(void *),

void *arguments );

Termino quando funo termina ou via:

int pthread_exit (void *status);

Um thread pode esperar por outro via:

int pthread_join (pthread_t thread, void **status_ptr);

Semforo
Semforo S: varivel no-negativa inteira que s pode se modificada pelos procedimentos up() e down() down(S) se S > 0: decremente S seno: bloqueia esperando up(S) up(S) se h algum bloqueado: desbloqueie seno: incremente S

Exemplo de Semforo
(* excluso mtua *) var mutex: semaphore := 1;

thread P1; statement X down(mutex); statement Y up(mutex); statement Z end P1;

thread P2; statement A; down(mutex); statement B; up(mutex); statement C; end P2;

Mutex Posix
Mutex um semforo binrio

down() chamado de lock() up() chamado de unlock()

Posix tem as seguintes operaes:

int pthread_mutex_init (pthread_mutex_t *mut, const pthread_mutexattr_t *attr); int pthread_mutex_lock (pthread_mutex_t *mut); int pthread_mutex_unlock (pthread_mutex_t *mut); int pthread_mutex_trylock (pthread_mutex_t *mut); int pthread_mutex_destroy (pthread_mutex_t *mut);

Condies
Mutex servem para proteo de regies crticas Alm disso, precisamos esperar que outro thread faa alguma coisa Resolvido em Posix atravs de condies

Condies Posix
int pthread_cond_init (pthread_cond_t *cond, pthread_condattr_t *attr); int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut); int pthread_cond_signal (pthread_cond_t *cond); int pthread_cond_broadcast (pthread_cond_t *cond); int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mut, const struct timespec *abstime); int pthread_cond_destroy (pthread_cond_t *cond);

Exemplo Posix
Produtor/Consumidor retirado de www.uq.edu.au/~cmamuys/humbug/talks/ pthreads/pthreads.html

Monitores
Lidar com mutexes e condies muito baixo nvel e muito sujeito a erros Monitores encapsulam sees crticas como procedimentos de um modulo, sendo portanto muito mais fceis de programar

Todas as chamadas ao procedimentos so executadas sob excluso mtua Estruturas de sincronizao esto embutidas no monitor

Threads Java
Java tem monitores orientados a objeto Em Java, existe um lock associado a cada objeto que no pode ser acessado diretamente pela aplicao Quando um mtodo identificado como synchronized, o acesso e feito apenas quando o lock associado com o objeto obtido

Criando Threads em Java [1]

public class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() { [ cdigo do thread ] } }

Criando Threads em Java [2]

public class C extends D implements Runnable { private Thread thread = null; public void start() { if (clockThread == null) { thread = new Thread(this, CThread"); thread.start(); } } public void run() { [cdigo do thread ] } }

Excluso Mtua em Java

class SharedInteger { private int theData; public SharedInteger(int initialValue) { theData = initialValue; } public synchronized int read() { return theData; } public synchronized void write(int newValue) { theData = newValue; } }

Sincronizao em Java
Java associa condies a cada objeto wait() espera pela condio do objeto notify() e notifyAll() acordam threads esperando pela condio

Exemplo Java
Produtor/Consumidor retirado de java.sun.com/docs/books/tutorial/essen tial/threads

ProducerConsumerTest.java CubbyHole.java Producer.java Consumer.java

Agradecimentos
A Fabricio Silva que gentilmente nos forneceu seu material sobre tempo real, usados como base destas transparncias