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
către 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 către 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.
 Campuri volatile

• În timpul rulării firele de execuție care pot rula pe procesoare diferite, pot copia
campuri ale obiectelor în memoria cache a procesorului
• Câmpurile volatile sunt campuri la care modificarile din copie sunt facute si în
memoria principală
• Cuvântul cheie volatile face astfel vizibil campul pentru toate firele de executie
 Crearea colecțiilor sincrone

Sunt create prin metode statice ale clasei Collections:

public static <T> Collection<T> synchronizedCollection(Collection<T> c);

public static <T> Set<T> synchronizedSet(Set<T> s);
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s);
public static <T> List<T> synchronizedList(List<T> list);
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m);