Elemente de programare concurenta - Sincronizarea firelor

prin join
Sincronizarea prin join este utilizata cand calculul paralel este urmat de alte
operatii care folosesc rezultatele acestuia. Exemplu: sortarea partitionata prin
interclasare a vectorilor de mari dimensiuni.
Metodele join:
public final void join(long millis, int nanos) throws InterruptedException;
public final void join() throws InterruptedException;

Studiu de caz: Inmultirea matricelor de mari dimensiuni

Matrici dense de mari dimensiuni : C =A x B.

Complexitatea seriala este O(n3).
Operatii matriceale pe blocuri:

Matricea A de n*m elemente este impartita in p blocuri linie, fiecare bloc

continand maxim n/p+n%p linii
Matricea B de m*q elemente este impartita in p blocuri coloana, fiecare bloc
continand maxim q/p+q%p coloane.

Se executa p2 inmultiri de matrice bloc

Un fir oarecare Pi,j inmulteste blocul linie Ai cu blocul coloana Bj , i=1,p, j =
1,p si calculeaza blocul Ci,j al matricei rezultat

Sincronizarea firelor de executie

Firele de executie pot fi monitorizate pentru atingerea unor obiective comune.
In acest scop sunt utilizate urmatoarele mecanisme:
Excluderea reciproca
Utilzarea metodelor wait() si notify()
Excluderea reciproca este mecanismul prin care se asigura accesarea de
ctre un singur fir, la un moment dat a unor resurse.
Metode de excludere:
Utilizarea metodelor sincrone
Utilizarea blocurilor sincrone
Utilizarea semafoarelor

Obiectul Monitor este obiectul care contine resursa (sectiunea critica) si

metodele sincrone prin intermediul careia aceasta resursa este accesata.
Metodele sincrone, marcate prin modificatorul synchronized, sunt metode
care se pot executa de ctre un singur fir i integral la un moment dat.
Blocurile sincrone au rolul de a extinde excluderea reciproca dincolo de
granitele unei metode sau de a limita excluderea la o anumita parte dintr-o
metoda.
Sintaxa:
try (obiectMonitor|this){
// sectiune executata in mod sincron
}
Cand se utilizeaza this se face limitarea accesului sincron in metoda curenta
la sectiunea cuprinsa intre acolade.
Cand se utilizeaza un obiect monitor, accesul la acesta este restrictionat
pentru alte fire in sectiunea de cod cuprinsa intre acolade.

Metodele wait si notify sunt utilizate in monitorizare de catre obiectul monitor,

astfel:

public final void wait() throws InterruptedException; // pune in asteptare firul

current pana la "eliberarea" lui printr-o metoda notify executata prin monitorul
curent
public final void wait(long timeout) throws InterruptedException; // pune in
asteptare firul current pana la expirarea timpului sau "eliberarea" printr-o
metoda notify lansata de monitorul curent
public final void notify(); // trece un fir aflat in asteptare printr-un wait al
monitorului current, in starea ready
public final void notifyAll(); // trece toate firele puse in waiting de monitorul
current, in starea ready
Exemplu: scenariul Producator-Consumator

Semafoare
Sunt implementate prin clasa Semaphore , pachetul java.util.concurrent
public class Semaphore extends Object implements Serializable;
Restrictioneaza numarul de fire care au acces la o regiune critica
Constructori:
public Semaphore(int permits); // creaza un semafor cu numar de permisiuni
specificat
public Semaphore(int permits, boolean fair); // fair specifica daca se respecta
ordinea in castigarea permisiunii. Pentru primul constructor fair este false
Metode:
public void acquire() throws InterruptedException; // Obtinere permisiune sau
trecere fir in asteptare pana cand o permisiune este acordata sau firul este
intrerupt. Obtinerea permisiunii duce la decrementarea numarului de
permisiuni.
public void acquire(int permits) throws InterruptedException; // Este solicitat
un numar de permisiuni. Obtinerea implica decrementarea cu permits.

public void release(); // Eliberarea unei permisiuni semaforului. Numarul de

permisiuni este incrementat cu 1.
public void release(int permits); // Elibearea unui numar de permisiuni
public int availablePermits(); // Intoarce numarul de permisiuni disponibile
public boolean tryAcquire(); // Incearca obtinerea unei permisiuni. Insuccesul
nu implica trecerea in asteptare.
public boolean tryAcquire(long timeout, TimeUnit unit) throws
InterruptedException; // Idem dar pe perioada unui timeout. In aceasta
perioada firul poate sta in asteptare. Unit indica unitatea de masura pentru
timeout.