Cuprins e7g13gf

1. Introducere
1.1 Motivatie
1.2 Thread-uri
1.3 Java

2. Threading with Java
2.1 Crearea Thread-urilor
2.2 Executia paralela a thread-urilor
2.3 Starile thread-urilor
1.4 Avantajele thread-urilor
1.5 Grupuri de thread-uri

3. Sincronizare
3.1 Monitoare
3.2 Bariere
3.3 Asteptarea terminarii unui thread
3.4 Saracire
3.5 Interblocare

Anexa A : Algoritmi multisegment
Anexa B : Problema producator-consumator

1. Introducere

1.1 Motivatia

Un sistem multiprocesor (SM) este un mecanism care permite unui sistem de a folosi mai mult de un procesor. Sistemul Mutiprocesor Simetric (SMS) este o parte a Calculului Paralel unde toate procesoarele sunt identice. In SMS procesoarele sunt dirijate in asa fel incit sarcinile sunt impartite de catre sistemul de operare iar aplicatiile sunt executate pe mai multe procesoare care impart acelasi spatiu de memorie. SMS garanteaza ca intreg numarul de procesoare deserveste sistemul de operare. Fiecare sub-proces poate fi executat pe orice procesor liber. Astfel se poate realiza echilibrarea incarcarii intre procesoare. Java contine citeva caracteristici care-l fac un limbaj ideal pentru SMS. Este un limbaj orientat obiect foarte simplu si cel mai important, este conceput sa suporte programare multiprocesor. In acest laborator vom prezenta felul in care Java ajuta sa cream aplicatii paralele. Vom face aceasta intr-o maniera incrementala, aratind cum se foloseste fiecare caracteristica a limbajului.

1.1 Thread-uri

Ce sunt thread-urile?

Thread-ul reprezinta executia liniara a unei singure secvente de instructiuni care ruleaza in interiorul programului nostru. Toti programatorii sunt familiarizati cu scrierea programelor secventiale. Programele secventiale au un punct de start, o secventa de executie si un punct terminal. Cel mai important lucru la programul secvential este acela ca la orice moment o singura instructiune este executata. Thread-ul este similar cu un program secvential in sensul ca thread-ul are si el un punct de start, o secventa de executie si un punct terminal. De asemenea intr-un thread se executa doar o singura instructiune la un moment dat. Si totusi un thread nu este la fel ca un program obisnuit.
Spre deosebire de programe, thread-ul nu poate exista de unul singur. Thread-urile coexista in interiorul unui program. Deci putem avea mai multe thread-uri care se executa simultan.

De ce sa folosim thread-uri?

Un singur thread nu ofera nimic nou. Orice program scris pina acum avea cel putin un thread in el. Noutatea apare atunci cind vrem sa folosim mai multe thread-uri, ceea ce inseamna ca aplicatia noastra poate sa faca mai multe lucruri in acelasi timp. Fiecare thread poate sa faca altceva in acelasi timp: unul sa incarce o pagina Web in timp ce altul animeaza o icoana sau toate pot colabora la acelasi job (generarea unei imagini 3D). Cind se foloseste corespunzator multithreading-ul cresc mult performantele appletului sau aplicatiei unde este folosit. Multithreading-ul poate simplifica fazele de proiectare si planificare a tuturor aplicatiilor greu de realizat intr-un program secvential. Astfel poate ajuta programatorul pentru a crea programe mai performante (caracteristica programmer friendly). Un exemplu bun de thread-uri este un procesor de text care poate sa tipareasca o pagina (paginare, incadrare si trimitere catre imprimanta) in background. Se poate continua editarea in timp ce pagina este trimisa catre imprimanta. Va imaginati cit de greu ar fi de scris un program secvential intretesut care sa realizeze acest lucru?
Utilizand thread-uri putem avea un thread care tipareste si unul care permite utilizatorului sa continue editarea. Alt exemplu este acela a unui browser Web care permite defilarea unui text al unei pagini pe care tocmai a-ti incarcat-o in timp ce browser-ul se ocupa cu aducerea imaginilor. Ce neplacut ar fi sa astepti incarcarea unei intregi pagini pe care o gasesti in final neinteresanta.
Thread-urile pot realiza de asemenea calculul mai rapid. Prin segmentarea unui task in subtask-uri si apoi avind cite un thread pentru fiecare subtask se poate creste mult viteza de executie. Aceasta este general valabil pentru un SMS.
Cind se executa doua thread-uri, ele vor fi executate simultan fiecare pe cite un procesor si astfel se realizeaza o crestere semnificativa a vitezei. Avantaje similare se obtin cind se utilizeaza Java pe alte platforme de calcul paralel si distribuit cum ar fi Sistemele cu Memorie Distribuita (SMD).

Concurenta thread-urilor.

Fara a intra intr-o discutie pe teme hardware, este bine de spus ca procesoarele calculatoarelor pot executa doar o instructiune la un moment dat. De ce spunem ca thread-uri diferite se executa in acelasi timp?
Spunind simultan nu inseamna numai lucruri in medii diferite. Pe o masina multiprocesor, thread-urile pot exista pe procesoare diferite in acelasi timp fizic, aceasta mentinindu-se valabil chiar daca procesoarele sunt pe calculatoare diferite conectate intr-o retea. Dar si pe o masina cu un singur procesor, thread-urile pot imparti acelasi procesor, rulind intr-o maniera intretesuta, competitia pentru timpii CPU creind iluzia ca ele se executa simultan. Aceasta iluzie pare reala cind 30 de imagini distincte pe secunda captate de ochiul uman sunt percepute intr-un flux continuu de imagine. Aceasta comutare intre thread-uri are si ea un pret. Consuma timp CPU pentru ca acesta sa inghete starea unui thread si sa dezghete starea unui alt thread (schimbare de context). Daca thread-urile concurente sunt executate pe acelasi procesor si toate executa calcule atunci timpul total de executie nu va lua mai mult decit timpul de executie al unui program secvential care realizeaza acelasi lucru.
Din moment ce intr-un sistem monoprocesor thread-urile concura la timpul procesor cum este posibil cresterea vitezei sistemului? Aceasta se realizeaza prin intreteserea diferitelor faze ale diferitelor thread-uri. Multe task-uri pot fi segmentate logic in tipuri de faze: faza de calcul si faza I/O. Faza de calcul necesita atentia maxima din partea CPU-ului prin utilizarea diferitelor metode de calcul. Faza de I/O (intrare/iesire) necesita atentie maxima din partea perifericelor
(imprimante, hard discuri, placi de retea, etc) si in aceste situatii procesorul este in general liber, asteptind ca perifericul sa-si termine sarcina. Cresterea vitezei este obtinuta prin intreteserea fazelor. In timp ce un thread se afla intr-o faza de I/O asteptind ca o secventa de date sa fie incarcata de pe hard disk, un thread cu o faza de calcul poate ocupa procesorul si cind ajunge la o faza I/O, celalalt thread (care tocmai a terminat faza I/O proprie) poate incepe sa utilizeze CPU-ul.

Contextul thread-urilor si memoria distribuita

Thread-urile ruleaza in contextul unui program, folosind resursele acestuia.
Fiecare thread are propriile variabile si puncte de executie, dar variabilele globale sunt impartite de toate thread-urile. Deoarece ele impart acelasi spatiu (variabilele globale si alte resurse) toate acestea pot accesa la un moment dat aceeasi data. Este important de observat ca memoria comuna prezinta o degradare a performantelor cind lucreaza cu un cluster de computere conectate intr-o retea, asemenea cazului unui sistem distribuit de tip clustere de PC-uri.
Obiectele care sunt comune trebuie sa fie transmise pe retea de atitea ori de cit este nevoie. In asemenea mediu distribuit, reteaua poate fi privita ca o resursa cu efect secvential (git de sticla). Pentru un programator intr-un sistem cu memorie distribuita, impartirea memoriei este un lucru transparent, relativ la nivelul cel mai adinc al sistemului de operare. Oricum, in asemenea sisteme, trebuie avut o atentie sporita pentru a minimiza utilizarea concurenta a variabilelor comune de mai multe thread-uri, deoarece aceasta situatie ar putea degenera intr-o sufocare a aplicatiei.

1.3 Java

Java este un limbaj de programare orientat obiect, simplu, robust, sigur, cu arhitectura neutra, ce permite multithreading, dinamic dezvoltat de firma Sun
Microsystems. Bazat pe sintaxa C++, Java este un limbaj simplu de invatat de cei care au cunostinte de baza din C si C++.

Principalele carateristici Java

Java a fost creat nu numai pentru ca este portabil pe orice platforma de sistem de operare ci de asemenea prezinta caracteristica ca este compilat in forma binara (binary form compiled). Spre deosebire de un cod executat pe o masina care pe alte platforme este imposibil de executat, Java este compilat intr-un limbaj masina intermediar
(o secventa de instructiuni numita byte-code) care este interpretat din mers de interpretorul Java. Compilarea Just In Time (JIT) permite byte-code-ului de a rula la fel de repede ca un cod masina nativ. Interpretorul Java este o colectie de thread-uri care realizeaza task-uri diferite pentru a putea suporta executia unui program Java. Intre thread-urile interpretorului sunt cele a caror sarcina este de a executa instructiuni byte-code, unul care gestioneaza iesirea grafica si colectorul de deseuri (garbage collector). Fiind un limbaj orientat obiect complet, Java suporta atit clase cit si interfete. O interfata care este o declaratie a tipului unei clase, impreuna cu definirea unui set de metode (functii) pe care clasa respectiva le implementeaza.
Interfetele sunt clase virtuale C++, care contin metode virtuale pure. Java suporta mostenirea simpla (numai o clasa de baza pentru o clasa derivata), dar adauga calitatea de polimorfism pentru implementarea interfetelor multiple.
Java capata robustete prin eliminarea necesitatii alocarii de memorie. Pentru a facilita aceasta cit si alte caracteristici, Java foloseste instante de obiecte in loc de pointeri. Similar in folosire, instantele de obiecte pot fi create numai de sistem si apoi trimise catre aplicatia noastra. Cind ultimul obiect este eliberat nu exista nici o modalitate de a recapata controlul asupra lui si obiectul devine candidat pentru colector. Executind un thread care este colector in background este asigurat faptul ca memoria va fi eliberata oricind este nevoie. Din moment ce aplicatiile multiproces, procesoarele impart datele de la resursele comune, se ridica atunci problema excluderii reciproce. Java, de asemenea prezinta tot ce este necesar pentru task-uri, prezentind facilitatea de sincronizare. In plus, Java contine un mecanism de manipulare a grupului de thread-uri. Kit-urile de dezvoltare de Java actuale sunt disponibile pentru diferite platforme: Unix, Windows si alte sisteme de operare.

Java contra C++

Java a fost creat original deoarece C++ era inadecvat pentru task-uri efective.
Specialistii au fost in stare sa invete din experientele si greselile limbajelor orientate obiect anterioare si au adunat tot ce era mai bun intr-un nou limbaj.
In noul limbaj ei s-au bazat pe sintaxa limbajului C++ pentru a permite invatarea mai rapida a limbajului. Ei au adaugat citeva lucruri fata de C++ cum ar fi colectorul si suportul pentru multithreading si au renuntat la unele caracteristici C++ care s-au dovedit mai bune in teorie decit in practica cum ar fi mostenirea multipla. Design-erii limbajului Java, au scos si caracteristicile pe care C++ le-a mostenit de la C cum ar fi dealocarea de memorie si pointeri aritmetici, definirea de tipuri (typedefs), uniuni si structuri, supraincarcarea operatorilor si tipuri enumerare, functii de sine statatoare si directive de compilare (#define, #include,#ifdef,etc).

Applete contra aplicatii

Applet-urile sunt aplicatii speciale Java care pot fi incarcate si executate de catre browser-ele Web. Apleturile pot fi integrate in paginile Web si sunt automat incarcate cind browser-ul afiseaza aceste pagini. Spre deosebire de aplicatii, apletele nu pot fi executate in afara browser-ului Web. Din moment ce apletele sunt incarcate de catre browser-ele Web de la un server Web si se executa pe masina locala a utilizatorului, ele au unele restrictii. In era virusilor de calculatoare este crucial ca o aplicatie sa nu fie in stare sa acceseze fisierele protejate de pe masina utilizator sau sa stearga intregul continut al HDD-ului. Avind in vedere aceasta problema, proiectantii limbajului
Java au limitat accesul in applet, permitind conectare numai in locul de unde au fost solicitate. Nici o restrictie nu este pusa applet-ului in privinta crearii unui thread. Incarcarea unui applet poate genera crearea unui numar mare de thread-uri, facind ca procesorul sa se supraincarce. Aceasta nu este o problema majora din moment ce nu dauneaza securitatii sistemului.

Java pe scurt

Limbajul Java prezinta caracteristicile:

1 Tipuri bine definite de obiecte.
2 Nu contine pointeri aritmetici, nu necesita alocare si dealocare de memorie si nu foloseste pointeri cast "falsi".
3 Java este un limbaj orientat obiect. Astfel incapsularea, polimorfismul sunt usor de atins.
4 Nu exista contructii nesigure.
5 Este un limbaj mic si are o infatisare familiara, astfel el devine fluent.
6 Concurentialitatea: Java este un limbaj multithreading. Modelul include thread-uri si posibilitati de sincronizare (bazat pe conceptul de monitor).
7 Multitaskingul este realizat in pagini de memorie comune.

Rezumind, putem spune simplu ca mediu Java care ruleaza pe un Sistem Multiprocesor Simetric creaza cea mai puternica combinatie soft-hard.

2. Programare multithreading in Java

Dupa ce ne-am familiarizat cu conceptul de thread este timpul sa vedem cum este suportat multithreading-ul de catre Java. Thread-urile Java sunt implementate de clasa Thread care este parte din package-ul java.lang. Clasa Thread implementeaza thread-urile independente sistem. Actuala implementare a thread-urilor este realizata de catre sistemul de operare si clasa Thread permite interfatarea cu toate sistemele.

2.1 Crearea unui Thread, crearea unui thread de executie

In Java, fiecare thread este incapsulat intr-o clasa si ruleaza prin intermediul unor metode specifice in instanta unei clase. Aceasta instanta nu este o instanta a clasei Thread ci este o instanta a unei clase derivata din clasa
Thread sau a unei clase care implementeaza interfata Runnable (Runnable Interface).
Clasele care instantiaza astfel de obiecte sunt numite "runnable classes" si obiectele sunt numite "runnable objects". Executia unui thread incepe cu apelarea unei methode din clasa Runnable sau dintr-o subclasa a acesteia. Aceasta metoda se executa atita timp cit ea exista si atunci thread-ul moare (aceasta implica faptul ca o metoda care executa o bucla infinita ca thread-ul nu moare niciodata).
Un thread poate sa fie terminat ca urmare a unui eveniment extern cum vom vedea mai departe. Pentru ca un thread sa poata sa execute o metoda a clasei trebuie sa indeplineasca una din conditiile:

1 sa fie ori derivata din clasa Thread, fiind o clasa care incapsuleaza facilitatile thread-ului ori
2 sa implementeze interfata Runnable, o interfata in care orice clasa trebuie sa se comporte ca un thread separat. Clasa Thread de asemenea implementeaza interfata Runnable ).

class MyThread extends Thread A public void run() A

System.out.println ("Hello World!");
S
S
________________________________________________________________________

Acest exemplu de clasa derivata din clasa Thread suprascrie una din metodele sale - metoda run(). Metoda run() este cea mai importanta deoarece contine codul pe care thread-ul il va executa. Pentru majoritatea thread-urilor aceasta metoda contine o bucla infinita. Pentru a lansa in executie metoda run() mai intii trebuie creata o instanta a acestei clase, apoi sa se apeleza metoda start() a acestei clase. Metoda start() face thread-ul activ si invoca metoda run().
________________________________________________________________________

class MyTest A public static void main(String Argsai) A new MyThread().start();
S
S
________________________________________________________________________

Aceasta secventa de cod combinata cu clasa MyTread va afisa mesajul "Hello world!" pe ecran. Ce se intimpla de fapt aici : metoda main va starta thread-ul si se va termina. Thread-ul nu se va termina cind se va termina metoda main. El va executa metoda run() pina aceasta se termina. Metoda run() va afisa efectiv mesajul "Hello world!" pe ecran si apoi va iesi. Cind si metoda main() si metoda run() se vor fi terminat, se poate reda controlul sistemului. O alta metoda de a crea thread-uri este aceea ca o clasa sa implementeze interfata Runnable asa cum este aratat in exemplul urmator:

class MyThread implements Runnable A public void run() A
System.out.println ("Hello World!");
S
S

O clasa care implementeaza interfata Runnable poate fi derivata din orice clasa.

class MyTest A public static void main(String Argsai) A new Thread(new MyThread()).start();
S
S

Observam ca de aceasta data folosim un alt constructor al clasei Thread pentru a instantia un thread. Acest constructor necesita un parametru care este o referinta la o instanta a unei clase care implementeaza interfata Runnable. Mai exista si alti constructori in clasa Thread, cum ar fi : Thread(ThreadGroup, Runnable, String).
Parametrul ThreadGroup asigneaza thread-ul la un grup de thread-uri, o multime de thread-uri care permite ca toate thread-urile sa fie tratate ca un intreg.
Parametrul Runnable este sursa unei noi metode run() a unui thread (un handler catre un obiect Runnable). Parametrul de tip String suporta un nume pentru acest nou thread. Acest nume poate fi folosit impreuna cu metoda getName() a clasei Thread pentru o referire de tip mnemonic a unui thread. Acesti parametri sunt optionali (de altfel exista 7 tipuri diferite de constructori pentru clasa
Thread).

Thread-uri daemon

Multe sisteme prezinta thread-uri cu scopul de a facilita diverse servicii (servicii de I/O, ascultare pe socket, etc). Aceste thread-uri sunt majoritatea in stare idle si numai cind primesc un mesaj ele incep sa-si execute task-ul specific.
Aceste thread-uri sunt cunoscute ca "Daemon Threads". Orice thread poate deveni daemon prin apelarea metodei setDaemon() proprii cu valoarea true. Se poate verifica starea unui thread utilizand metoda isDaemon().

2.2 Executia paralela a thread-urilor

Cu toate ca exemplele de pina acum nu au fost in masura sa puna in evidenta vreun nivel de paralelism, ele de fapt au facut acest lucru. Odata ce s-a terminat executia instructiunii Thread.start(), instanta clasei MyThread isi incepe executia. Nu se poate spune cu siguranta ca mesajul de pe ecran a fost tiparit dupa terminarea metodei main(), tiparirea pe ecran putind avea loc si inaintea terminarii metodei main(). Totul depinde de felul in care au fost alocati timpii procesor la thread-uri si de faptul daca exista unul sau mai multe procesoare. Pentru a demonstra acest principiu, sa consideram urmatorul program si rezultatul lui:

class PrintThread implements Runnable A
String str; public PrintThread (String str) A this.str = str;
S public void run() A for (;;)
System.out.print (str);
S
S

class Test A public static void main (String Argsai) A new Thread(new PrintThread("A")).start(); new Thread(new PrintThread("B")).start();
S
S

Iesirea programului de mai sus poate arata cam cum urmeaza (rulat in Windows NT si pe o masina multiprocesor va fi sigur asa):

AAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBB...

Cu un numar egal de "A" si de "B". Acest exemplu este menit sa demonstreze faptul ca aceste doua thread-uri lucreaza in paralel.

Multithreading preemptiv contra multithreading non-preemptiv

Multithreading preemptiv inseamna faptul ca un thread poate fi preemptat (suspendat) de catre alt thread in timp ce se executa. Nu toate sistemele care suporta multithreading prezinta mecanism preemptiv. Iesirea aceluiasi program pe un sistem SPARC/Solaris 2.5 ar arata in felul urmator:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...

Acest lucru este datorat faptului ca pe Solaris (si nu numai) thread-urile nu sunt preemptive. Un thread trebuie sa aiba "o comportare echitabila" si sa renunte la timpul sau procesor in asa fel incit sa permita si altor thread-uri sa se executa. Renuntarea la propriul timp CPU in mod voluntar se realizeaza prin invocarea metodei proprii yield(). In continuare iata o versiune revizuita a clasei PrintThread care elibereaza CPU-ul dupa fiecare litera afisata:

class WellBehavedPrintThread implements Runnable A
String str; public PrintThread (String str) A this.str = str;
S public void run() A for (;;) A
System.out.print (str);
Thread.currentThread().yield();
S
S

Instructiunea Thread.currentThread().yield() utilizeaza o metoda publica a clasei Thread pentru a capata handler-ul catre thread-ul curent si apoi ii spune sa elibereze procesorul. Iesirea acestui exemplu este:

ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB
ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB
...

2.3 Starile thread-urilor

Creind o instanta a unui thread acesta nu este lansat. Aceasta sarcina de a lansa thread-ul in executie este realizata de metoda start(). Un thread se poate gasi in stari diferite in functie de evenimentele trecute. In tabelul urmator se pot observa starile in care se poate gasi un thread:

Stare Descriere Instanta nou creata

1. Metoda run() nu este in executie, timpul procesor nu este inca alocat. Pentru a starta un thread trebuie apelata functia start(). In aceasta stare se poate apela de asemenea metoda stop(), care va distruge thread-ul.

2. Thread in executie
Thread-ul a fost startat cu metoda start(). Este thread-ul pe care procesorul il executa in acest moment.

3. Thread gata de executie (runnable)
Thread-ul a fost startat dar nu este in executie pe procesor in acest moment.
Motivul ar fi acela ca thread-ul a renuntat la procesor apelind metoda yeld(), sau din cauza unui mecanism de programare a timpului procesor care a decis sa distribuie timpul procesor al acestui thread altui thread. Thread-ul va putea trece in executie cind mecanismul de programare va decide acest lucru. Atita timp cit exista un alt thread cu o prioritate mai mare, thread-ul nu va trece in executie.

4. Thread nepregatit pentru executie (non runable thread)
Thread-ul nu poate fi executat din anumite motive. Ar putea sa astepte o operatie de tip I/O sa se termine. A trebuit sa apeleze metoda wait(), sleep() sau suspend().

1. new Thread()
2.

Prioritatile thread-urilor

Fiecarui thread ii este asignata o prioritate cuprinsa intre MIN_PRIORITY
(egala cu 1) si MAX_PRIORITY (egala cu 10). Un thread mosteneste prioritatea de la thread-ul care l-a creat, dar aceasta prioritate se poate schimba apelind metoda setPriority() si aceasta prioritate se poate afla apelind getPriority().
Algoritmul de planificare intodeauna va lansa thread-ul cu prioritatea cea mai mare sa se execute. Daca exista mai multe thread-uri cu aceeasi prioritate maxima atunci procesorul le va executa intr-o maniera round-robin. Astfel un thread cu prioritate mica se poate executa numai atunci cind toate thread-urile de prioritate mai mare sun in starea non-runnable(). Prioritatea thread-ului main este NORM_PRIORITY( egala cu 5). Iata un exemplu de utilizare a prioritatilor:

class LowPriority extends Thread A public void run()A setPriority(Thread.MIN_PRIORITY); for(;;)A
System.out.println("The LOW priority thread is running");
S
S
S class HighPriority extends Thread A public void run()A setPriority(Thread.MAX_PRIORITY); for(;;)A for (int i=0; i<5; i++)
System.out.println("The HIGH priority thread is running"); try A sleep(100);
S catch (InterruptedException e) A
System.exit(0);
S
S
S
S

class Spawner A public static void main( String argsai ) A
LowPriority l = new LowPriority();
HighPriority h = new HighPriority();
System.out.println("Starting threads..."); l.start(); h.start();
System.out.println("MAIN is done");
S
S

Iesirea acestui program va arata ca mai jos:

Starting threads...
The LOW priority thread is running
The LOW priority thread is running
The HIGH priority thread is running
The HIGH priority thread is running
The HIGH priority thread is running
The HIGH priority thread is running
MAIN is done
The LOW priority thread is running
...
The LOW priority thread is running
The HIGH priority thread is running
The HIGH priority thread is running
The HIGH priority thread is running
The HIGH priority thread is running
The LOW priority thread is running
...
The LOW priority thread is running
The HIGH priority thread is running
^C

Sa analizam putin iesirea programului:

1. Prima linie este afisata de thread-ul principal. Thread-ul principal lanseaza thread-ul de prioritate minima si thread-ul de prioritate maxima.
2. Threadul de prioritate minima incepe sa se execute, acesta este facut imediat non-runnable de catre un thread de prioritate mai mare.
3. Thread-ul de prioritate mai mare incepe sa se execute, isi seteaza prioritatea maxima si astfel isi incepe executia. Dupa afisarea a 5 linii, thread-ul este
"adormit" si thread-ul main devine cel mai prioritar.
4. Thread-ul main afiseaza un mesaj dupa care se termina. In acest moment singurul thread gata de executie (runnable) este thread-ul de prioritate mica.
5. De aici incolo iesirea programului va arata la fel.
6. Thread-ul de prioritate mica va afisa mesaje proprii pina cind thread-ul de prioritate mai mare se va trezi.
7. Thread-ul de prioritate mare incepe sa se execute, afiseaza 5 linii si
"adoarme" din nou.
8. Thread-ul de prioritate minima poate rula din nou

Sistemul poate genera o exceptie de tipul IllegalThreadStateException cind este apelata o metoda a unui thread cind starea acestuia nu permite acest lucru. De exemplu, exceptia, IllegalThreadStateException este generata cind se face apelul metodei suspend() unui thread care nu este runnable. Si un ultim amanunt despre starile thread-urilor: clasa Thread cuprinde o metoda numita isAlive() care returneaza true daca thread-ul a fost startat dar nu stopat si false cind thread-ul este in starea new Thread sau Dead. Nu se poate face distinctie intre un thread in stare new Thread si un thread in stare Dead si nici intre unul

Runnable si unul not Runnable.

Grupuri de thread-uri

Fiecare thread apartine unui grup de thread-uri. Un grup de thread-uri este o multime de thread-uri (si posibil grupuri de thread-uri) impreuna cu un mecanism de realizare a operatiilor asupra tuturor membrilor multimii. Grupul implicit de thread-uri este implicit numit main, si fiecare group de thread-uri nou creat apartine acestui grup, mai putin acelea specificate in constructorul sau. Pentru a afla pentru un thread la ce grup de thread-uri apartine se poate folosi metoda getThreadGroup(). Pentru a crea propriul nostru grup de thread-uri, trebuie mai intii sa creem un obiect ThreadGroup. Se poate folosi unul din acesti constructori : ThreadGroup(String) - creaza un nou ThreadGroup cu numele specificat. ThreadGroup(threadGroup, String) - creaza un nou ThreadGroup cu numele specificat si apartinind la un anumit grup de thread-uri. Dupa cum arata si al doilea constructor, un grup de thread-uri poate fi creat in interiorul altui grup de thread-uri. Cel mai nou grup de thread-uri creat devine membru la cel mai vechi realizindu-se astfel o ierarhie de grupuri. Pentru a crea un thread in interiorul unui grup de thread-uri, altul decit grupul main trebuie doar mentionat numele grupului atunci cind se apeleaza constructorul thread-ului.
In momentul in care avem mai multe thread-uri organizate intr-un grup de thread-uri putem apela la operatii comune pentru toti membrii acestui grup.
Aceste operatii sunt in principal stop(), supend() and resume() care au aceeasi semnificatie ca atunci cind se foloseste un singur thread. Pe langa aceste operatii mai exista si alte operatii specifice grupului de thread-uri (vezi
"Java Application Programing Interface").

3.0 Sincronizare

Cind se utilizeaza mai multe thread-uri avem nevoie de o sincronizare a activitatilor lor. Exista cazuri in care dorim sa prevenim accesul concurent la structurile de date ale programului care reprezinta secvente comune acestor thread-uri. Limbajul Java ne ajuta in acest sens cu ajutorul unui mecanism de sincronizare si excludere mutuala (permite numai unui singur thread sa opereze asupra unei sectiuni critice). Sincronizarea dintre thread-uri in Java se realizeaza folosind metodele notify() si wait(). Ecluderea mutuala se realizeaza prin folosirea monitoarelor.

Motivarea sincronizarii

Sa consideram urmatoarea clasa al carei obiectiv este de a stoca date:

class MyData A private int Data; public void store(int Data) A this.Data=Data;
S public int load() A return this.Data;
S
S

Acum sa presupunem ca avem doua thread-uri: unul care incearca sa depoziteze o valoare si unul care incearca sa scoata o valoare. In continuare se prezinta codul care creaza cele doua thread-uri. Pentru a simula procesarea in timp real, vom cere thread-urilor sa "adoarma" dupa fiecare extragere de data:

class Main A// Clasa utilizata pentru a pune lucrurile in miscare public static void main(String argvai) A
MyData data = new MyData(); new Thread(new Producer(data)).start(); new Thread(new Consumer(data)).start();
S
S

class Producer implements Runnable A//Thread-ul - Producator
MyData data; public Producer(MyData data) A this.data=data;
S public void run() A int i; for (i=0;;i++) A data.store(i);
System.out.println ("Producer: "+i); try A
// "adormire" de 0 pina la 0.5 sec
Thread.sleep ((int) (Math.random()*500));
S catch (InterruptedException e) A S
S
S
S

class Consumer implements Runnable A //Thread-ul - Consumator
MyData data; public Consumer(MyData data) A this.data=data;
S public void run() A for (;;) A
System.out.println ("Consumer: "+data.load()); try A
Thread.sleep ((int) (Math.random()*500));
S catch (InterruptedException e) A S
S
S
S

Acest program consta din doua thread-uri: Consumer (consumator) si Producer
(producator). Producatorul "produce" si stocheaza datele in structura comuna celor doua thread-uri utilizind metoda store(). Consumatorul extrage acele date din structura MyData comuna. La prima vedere codul pare a fi in regula, dar acesta nu este din moment ce iesirea programului arata astfel:

Producer: 0
Consumer: 0
Producer: 1
Consumer: 1
Consumer: 1
Producer: 2
Producer: 3
Consumer: 3
Producer: 4
Producer: 5
Consumer: 5
Producer: 6
Consumer: 6
Producer: 7
Consumer: 7
Consumer: 7
Producer: 8
Producer: 9
Producer: 10
Consumer: 10

Dupa cum se observa, numerele 2, 4, 8 si 9 sunt produse dar nu sunt niciodata consumate. Pe de alta parte, numerele 1 si 7 sunt produse o singura data, dar consumate de cite doua ori. Acest lucru este datorat ordinei gresite de executie.
In primul rind ca producatorul nu are cum sa stie daca consumatorul a consumat data si in consecinta suprascrie noua data. In al doilea rind, consumatorul nu are cum sa stie daca citeste noua valoare sau pe cea veche. Este deci nevoie de o comunicare intre cele doua thread-uri.

O prima solutie.

Pentru a rezolva aceasta problema se pot folosi variabile binare pentru a controla accesul la data. Flag-ul Ready va semnifica faptul ca noua data a fost produsa si este gata de consum si flag-ul Taken va semnifica faptul ca aceasta data a fost consumata si este gata de suprascriere.

class MyData A private int Data; private boolean Ready; private boolean Taken; public MyData() A
Ready=false;
Taken=true;
S public void store(int Data) A
while (!Taken); this.Data=Data;
Taken=false;
Ready=true;
S public int load() A int Data;
while (!Ready);
Data = this.Data; //Salvare, deoarece dupa ce
//Taken devine true, Data se poate schimba oricand
Ready=false;
Taken=true; return Data;
S
S

Utilizind codul de mai sus vom obtine rezultatul asteptat : fiecare numar este consumat o singura data si toate numerele sunt consumate. Oricum aceasta solutie are un dezavantaj major : metodele store() si load() folosesc bucle, thread-urile testeaza in mod constant flag-urile pentru a vedea daca valorile lor s-au schimbat. Utilizarea buclelor de test ar putea determina ca acest program sa nu functioneze pe platforme nepreemptive deoarece thread-urile nu elibereaza procesorul si astfel thread-ul care trebuie sa schimbe o valoare, poate sa nu fie planificat pentru executie (aceasta problema ar putea fi rezolvata folosind apelurile metodei yield() in aceste bucle). O alta problema in aceste conditii poate aparea atunci cind se foloseste acelasi cod dar cu mai multi consumatori.
Rulind mai mult de un thread de tip Consumer vom avea mai multe thread-uri care consuma din aceeasi sursa ceea ce ar putea conduce la situatii cind aceeasi valoare este consumata de mai multe ori. Iata in continuare un exemplu de concurenta intre Consumatori:

Consumer1 Consumer2 Producer
while(!Ready)
while(!Ready) this.Data = Data;
Taken = false;
Ready = true
Data = this.Data;
Data = this.Data;
Ready = false;
Taken = true; return Data;
Ready = false;
Taken = true; return data;

Dupa cum se poate observa cei doi consumatori consuma aceeasi valoare. Aceasta se poate intimpla usor cind thread-urile impart acelasi procesor prin preemptare, sau procesoare multiple care ruleaza thread-urile in acelasi timp. O solutie la aceasta ultima problema este utilizarea mecanismului de sincronizare din Java, mecanism care are la baza monitorul.

3.1 Monitoare

Ce este un monitor?

Un monitor (pentru prima data introdus de Hoare in 1974) este asociat intodeauna cu o data specifica si o functie care controleaza accesul la aceasta data. Cind un thread retine un monitor pentru a accesa o data, celelalte thread-uri sunt blocate si nu pot avea acces la acea data. Un thread poate prelua un monitor numai atunci cind celelalte thread-uri nu l-au preluat si il poate elibera cind doreste. Poate exista un monitor pentru fiecare instanta a unei clase care are o metoda declarata ca synchronized. Declararea unei metode synchronized indica faptul ca numai acest thread care contine monitorul poate executa aceasta metoda.
Daca nici un thread nu a preluat monitorul, apelarea unei astfel de metode are ca efect preluarea acestui monitor. Achizitionarea monitorului este o operatie formata dintr-o singura instructiune care garanteaza faptul ca un singur thread va prelua acel monitor.

Sincronizarea utilizand monitoare

In urmatorul exemplu al clasei MyDatase foloseste metode de tip synchronized:

class MyData A private int Data; private boolean Ready; private boolean Taken; public MyData() A
Ready=false;
Taken=true;
S

public synchronized void store(int Data) A
while (!Taken); this.Data=Data;
Taken=false;
Ready=true;
S

public synchronized int load() A
while (!Ready);
Ready=false;
Taken=true; return this.Data;
S
S

Metodele "sincronizate" elimina nevoia de a stoca variabile de tip Data in interiorul metodei load(), astfel ca metodele load() si store() nu vor putea sa se execute in acelasi timp in thread-uri diferite. O problema apare, insa, cind un thread este "surprins" intr-o bucla de test si detine inca monitorul.
Celalalt thread nu va mai fi niciodata capabil sa-si execute propriul cod deoarece nu poate prelua monitorul. Doua thread-uri sunt in stare de interblocare cind unul dintre ele asteapta ca o valoare sa se schimbe in timp ce-l impiedica pe celalalt sa modifice acea valoare. Lucrul de care avem nevoie este de a prelua monitorul dupa ce a asteptat ca un flag sa se modifice. Solutia este de a folosi cuvintul cheie synchronized in asa fel incit sa protejam numai segmentul de cod critic care are nevoie de excludere mutuala:

class MyData A private int Data; private boolean Ready; private boolean Taken; public MyData() A
Ready=false;
Taken=true;
S

public void store(int Data) A
while (!Taken); synchronized (this) A this.Data=Data;
Taken=false;
Ready=true;
S
S public int load() A
while (!Ready); synchronized (this) A
Ready=false;
Taken=true; return this.Data;
S
S
S

De notat faptul ca atunci cind folosim cuvintul cheie synchronized pe un segment de cod, trebuie sa declaram obiectul insusi ca parametru al lui synchronized. Si totusi o problema ramine: bucla de test. Aceasta practica de a folosi bucle de test este considerata a fi gresita pentru thread-uri: consumatoare mare de timp procesor intr-o implementare preemptiva care, dupa cum s-a vazut, cauzeaza interblocarea intr-o implementare nonpreemptiva.

Asteptarea de evenimente

Exista totusi o cale de a evita buclele de test si in acelasi timp de a elimina necesitatea folosirii unuia din flag-uri utilizate pentru sincronizare. Solutia este de a folosi metodele wait() si notify() care sunt membre ale clasei Object din care este derivata orice clasa (aceste metode exista pentru orice obiect in Java). Metodele wait() si notify() sunt utilizate pentru determinarea asteptarii unui eveniment si respectiv trimiterea lor la un thread. Acest mecanism functioneaza dupa cum urmeaza: metoda wait() face ca thread-ul sa elibereze monitorul si il comuta pe acesta din starea runnable in starea non-runnable. Thread-ul va astepta in aceasta stare din urma pina cind este
"trezit" de un apel al metodei notify(). Cind un thread isi termina "asteptat-ul" el va recapata monitorul. Metoda notify() alege in mod arbitrar un thread din cele care sunt in asteptare si il elibereaza de aceasta stare. Metodele wait() si notify() sunt utilizate in clasa MyData dupa cum urmeaza:

class MyData A private int Data; private boolean Ready; public MyData() A
Ready=false;
S public synchronized void store(int Data) A

while (Ready) try A
wait();
S catch (InterruptedException e) A S this.Data=Data;
Ready=true; notify();
S public synchronized int load() A
while (!Ready) try A
wait();
S catch (InterruptedException e) A S
Ready=false; notify(); return this.Data;
S
S

In acest moment avem rezultatele dorite: fara a avea bucle wait si fara probleme de sincronizare. De observat faptul ca metodele wait() si notify() pot fi apelate numai din metode synchronized. A fi reentrant inseamna faptul ca codul clasei este protejat impotriva accesului multiplu. Toate clasele construite in Java sunt reentrante ceea ce inseamna ca ele pot fi folosite in programarea multithreading fara probleme. Din moment ce Java este pentru reutilizarea obiectelor si din moment ce nu stim cind sa utilizam o clasa din nou, este necesar sa o proiectam reentranta inca de la inceput. Ultima implementare a clasei MyData este o implementare reentranta. Sa vedem ce se intimpla cind mai multe thread-uri incearca sa acceseze aceeasi metoda simultan:

a. Mai multi consumatori - un singur producator.

Consideram urmatoarea problema: producatorul nu a produs inca nimic. Primul consumator preia monitorul dar va intra in wait() si-l va elibera permitind ca al doilea consumator sa urmeze aceeasi cale. Vom avea eventual toti consumatorii in stare wait() si monitorul eliberat. In acest moment producatorul intra in actiune: produce si apeleaza notify(). Aceasta cauzeaza faptul ca unul din thread-urile in wait() incearca sa preia monitorul. Din moment ce producatorul tocmai a eliberat monitorul iesind din segmentul de cod synchronized aceasta nu va cauza nici o problema. Consumatorul va "consuma" data si va apela notify().
Acest notify() va "trezi" alt thread care va gasi ca nu exista nimic de citit pentru moment si astfel se va reintoarce in wait() eliberind din nou monitorul.
Producatorul va fi din nou capabil sa-l preia si sa emita un nou numar.

b. Mai multi producatori - un singur consumator

Acum situatia este viceversa: acum sunt mai multi producatori si un singur consumator. Acum producatorii vor astepta (wait()) in timp ce consumatorul va
"trezi" pe fiecare dintre ei la un anumit timp permitindu-le sa genereze noi date. Deoarece Ready este false dupa ce consumatorul "consuma" fiecare valoare, un singur thread producator va produce o singura valoare. Deoarece producatorul va schimba starea flag-ului Ready ceilalti producatori nu vor suprascrie o noua valoare (chiar daca acestia sunt "treji") pina ce aceasta valoare nu este consumata.

3.2 Bariere

In aplicatiile multithreading este necesar ca anumite thread-uri sa se sincronizeze la un anumit punct. Un exemplu este calculul paralel in faza, in care toate thread-urile trebuie sa-si termine faza de executie inainte de a trece toate odata la faza urmatoare. O bariera este un mecanism folosit pentru a sincroniza mai multe thread-uri. Un thread care intilneste o bariera intra automat in wait(). Cind ultimul thread "ajunge" la bariera, semnaleaza (notify()) si celorlalte thread-uri care sunt in asteptare rezultind o "trecere" in grup a barierei. Iata un exemplu in acest sens:

import java.util.*;

class Barrier A // Clasa Barrier sincronizeaza toti
//participantii private int ParticipatingThreads; private int WaitingAtBarrier; public Barrier(int num)A //Constructorul obiectului
ParticipatingThreads = num;
WaitingAtBarrier=0;
S public synchronized void Reached() A //Metoda bariera
WaitingAtBarrier++; if ( ParticipatingThreads != WaitingAtBarrier ) A
//Inseamna ca thread-ul nu este ultimul try A
wait(); //Thread-ul este oprit pina ce //este eliberat
S catch (InterruptedException e) A S
S else A
// Acesta a fost ultimul thread activ notifyAll();
WaitingAtBarrier=0; // le elibereaza pe toate
S
S
S

Ajungind la bariera toate thread-urile, mai putin ultimul, asteapta in interiorul metodei synchronized ca ultimul thread ajuns sa le elibereze. Odata ce s-au
"trezit" ei intra in competitie pentru monitor si unul dintre ei il cistiga, apoi iese imediat eliberind monitorul. Celelalte thread-uri continua sa concureze pentru acest monitor si sa-l elibereze pina ce ultimul thread face acest lucru si-n acest moment sunt cu totii "liberi". In acest exemplu am presupus ca se cunoaste dinainte numarul de thread-uri participante. Daca, insa, acest numar nu este cunoscut dinainte poate fi aplicat un mecanism de inregistrare a participantilor. Orice thread care doreste sa astepte la bariera, mai intii trebuie sa se "inregistreze" incrementind numarul de thread-uri in asteptare. De unde stim ca toate thread-urile care asteapta la bariera s-au inregistrat? Ce se intimpla daca toate thread-urile mai putin unul si-au terminat de facut calculele si ultimul thread (care, probabil, nici nu a fost planificat sa ruleze inca) nu s-a inregistrat inca. Toate celelalte thread-uri vor trece bariera nestiind ca trebuie sa-l astepte si pe acesta din urma.

3.3 Asteptarea terminarii unui thread

Uneori este necesar a se astepta terminarea unui thread. De exemplu tread-ul principal (main) poate crea un al doilea thread pentru a executa ceva in interiorul lui. Java permite monitorizarea starii unui thread, altul decit cel in care se face aceasta operatie si suspendarea executiei pina ce acesta se termina. O metoda care poate fi folosita este metoda isAlive() care returneaza true daca thread-ul invocat nu este dead. Pentru asteptarea terminarii unui thread (fara a utiliza bucle) putem utiliza metoda join(). Aceasta metoda face ca un thread sa astepte pina cind un alt thread isi termina executia urmind sa-si reia executia in momentul in care thread-ul asteptat s-a terminat. Un thread poate fi intrerupt prin apelarea metodei interrupt(), caz in care metoda join() va
"arunca" exceptia InterruptedException. Iata un exemplu de program in care un thread asteapta un alt thread sa se termine:

Class MainThread extends Thread A public void run() A
SecondaryThread s = new SecondaryThread(); s.start();
// do my job...
// wait for the secondary thread to die if (s.isAlive()) s.join();
// We're done !
S
S

3.4 Alte metode de sincronizare

In regula, veti spune, Java are aceasta sincronizare cu monitoare dar eu vreau sa am vechile mele semafoare. Nici o problema. Utilizind monitoare se poate implementa orice obiect sincronizat dorit inclusiv semafoare. Iata in continuare un exemplu de semafor in Java:

class Semaphore A protected int value;
Semaphore( int initialValue ) A value = initialValue;
S
Semaphore() A value = 0;
S public synchronized void Get() A
while (value<1) wait(); value--;
S public synchronized void Put() A value++; notify();
S
S

3.5 Flaminzirea (Starvation)

Termenul de flaminzire caracterizeaza situatiile in care un thread este privat de resurse (accesul la un monitor). Spre deosebire de interblocare, in situatia de flaminzire calculele pot continua in sistem, doar ca thread-ul flaminzit nu mai poate continua. Flaminzirea se poate produce atunci cind un thread de prioritate mai mare isi incepe executia si nu mai elibereaza procesorul. De altfel toate thread-urile de prioritate mai mica sunt flaminzite.

3.6 Interblocarea (Deadlock)

Interblocarea se produce cind unul sau mai multe thread-uri asteapta schimbarea unei conditii in timp ce acea conditie este exclus sa se schimbe deoarece toate thread-urile care ar putea face acest lucru sunt in asteptare. Am vazut cum poate aparea un interblocaj atunci cind se folosesc bucle de test in interiorul unui monitor, asteptind ca un alt thread sa schimbe o conditie dar fara ai da posibilitatea de a obtine monitorul.

Anexa A: Algoritmul multisectiune

In aceasta anexa va prezentam un exemplu practic de utilizare a thread-urilor.
Vom implementa un algoritm multisectiune in Java. Un algoritm multisectiune este varianta paralela a algoritmului bisectiune sau (bisection). Ideia este urmatoarea : vrem sa aflam punctele unde functia f(x), continua pe un interval, trece prin valoarea 0 (zero). Se da un interval aa,bi si stim ca functia va trece o singura data prin valoarea zero in acest interval. Mai intii calculam f(a)*f(b). Daca rezultatul este mai mare ca zero, vom sti ca functia nu trece prin valoarea zero si se returneaza esec. Daca rezultatul este zero se verifica valorile f(a) si f(b), una din ele fiind sigur zero, deci avem o solutie.
Altfel divizam intervalul in p subintervale si se trece la executarea algoritmului pentru fiecare subinterval rezultat. Apoi se trece la executarea algoritmului asupra subintervalului care va returna succes. In continuare este prezentat algoritmul multisectiune in care apare un mecanism de sincronizare foarte asemanator mecanismului producator/consumator.

import java.lang.Math; // pentru functia abs()

class Bis A // Aceasta clasa detine functia main()
//care va face apelul recursiv public static void main (String Argsai) A
Bisection b = new Bisection(0,10); //instantiere
Thread t = new Thread(b); //creare thread t.start(); // lansarea lui if (b.waitForMe()) // asteptarea terminarii lui
System.out.println ("The result is: "+b.GetResult()); else
System.out.println ("Got NO RESULT.");
S
S abstract class Function A // efectiv, calculeaza public static double f (double x) A return (x*x­25);
S
S class Bisection implements Runnable A private double min; // detine intervalul private double max; private double Result; // contine rezultatul private boolean Status; // starea succesiunii private boolean Done; // Flag de sincronizare private final int p = 3; //numar de subsectiuni private final double e = 0.0000001; //marja public Bisection (double min,double max) A
// constructorul
Done=false; this.min=min; this.max=max;
S public void run () A
//Aici ia loc actiunea efectiv
Status=true; // optimism double fmin = Function.f(min); // calculeaza double fmax = Function.f(max); // functia if ((fmin*fmax)>0) A // Aproximatix, p-1/p va
Status=false; // esuare la acest stadiu, mynotify(); // asa ca va deveni primul return;
S if (fmin==0) A // Noroc
Result=min; mynotify(); return;
S if (fmax==0) A
Result=max; mynotify(); return;
S if (Math.abs(max-min)<e) A // Este aproximativ
Result=(max+min)/2; // Aceasta se va mynotify(); // intimpla in majoritatea return; // cazurilor
S
// De aici stim ca trebuie impartit in p parti
// si startat cite un thread pentru fiecare
Bisection subai = new Bisectionapi;
Thread tai = new Threadapi; for (int i=0;i<p;i++) A double nmin=(i*max-i*min+p*min)/p; double nmax=nmin+(max*min)/p; subaii = new Bisection(nmin,nmax); taii = new Thread (subaii); taii.start();
S
// Asteptam ca aceste thread-uri sa se termine
// Multe o vor face instantaneu, dar unul nu
Status=false; for (int i=0;i<p;i++) if (subaii.waitForMe()) A
Result = subaii.GetResult();
Status=true;
S mynotify(); // Punem rezultatul in Result.
S public double GetResult() A // Intoarce rezultatul return (Result);
S

synchronized void mynotify() A
// Aceasta este functia de sincronizare apelata
// cind iau sfirsit calculele. Ea seteaza
// flag-ul Done este true si apoi apeleaza
//waitForMe()
Done=true;
while (Done) A notify(); try A
wait(); //Motivul pentru care asteptam
// este acela ca dorim sa aflam daca
// waitForMe() a fost sesizata //(notify())
S catch (InterruptedException e) A S
S
S public synchronized boolean waitForMe() A
while (!Done) A // Asteapta pina ce se termina try A // dar nu intr-o bucla de test
wait();
S catch (InterruptedException e) A S
S
Done=false; notify(); // Trezeste mynotify() in asteptare.. return (Status);
S
S