Lucrarea 5 Fire de Execuţie în Java. Mecanisme de Sincronizare.

Transcription

1 Lucrarea 5 Fire de Execuţie în Java. Mecanisme de Sincronizare. În această lucrare vor fi prezentate mecanismele Java pentru programarea concurentă. Fire de Execuţie Există două moduri în care pot fi create noi fire de execuţie în Java. Primul mod constă în crearea unei subclase a clasei Thread şi suprascrierea metodei run(). Pentru fiecare fir de execuţie pe care dorim să-l rulăm trebuie să creăm un exemplar din noua clasă şi să-l lansăm apelând metoda start() a noului exemplar: public class FirThread extends Thread { public void run(){//aceasta este metoda care se execută concurent while(true) System.out.println("Iar eu sunt un firicel"); public static void main(string[] arg){ FirThread f=new FirThread(); f.start();//pornim run-ul lui f while(true) System.out.println("eu sunt firul principal"); Deoarece în Java nu avem moştenire multiplă, mecanismul anterior nu poate fi folosit întotdeauna. De aceea mai avem un mod de creare a unui nou fir de execuţie: crearea unei noi clase care să implementeze interfaţa Runnable, noua clasă trebuind să implementeze metoda run(). Pentru a porni un nou fir de execuţie se creează un exemplar din noua clasă care va fi pasat ca parametru la crearea unui obiect din clasa Thread. Firul se lansează în acelaşi mod, apelând metoda start a noului obiect Thread. public class FirRunnable implements Runnable { /** Creates new FirRunnable */ public void run(){//firul care se execută concurent

2 while(true) System.out.println("Iar eu sunt un firicel"); public static void main(string[] arg){ FirRunnable f=new FirRunnable();//exemplarul care trebuie pasat firului new Thread(f).start();//creăm firul şi-l pornim while(true) System.out.println("eu sunt firul principal"); Fiecare fir de execuţie are o prioritate, care este un număr din intervalul [MIN_PRIORITY,MAX_PRIORITY] şi care poate fi modificată cu ajutorul metodei: public final void setpriority(int newpriority) În general, atunci când există o competiţie pentru resurse sunt preferate firele care au prioritate mai mare dar nu există nici o garanţie în acest sens, şi nici că firul cu prioritatea cea mai mare va fi mereu în execuţie. Deci nu acesta va fi mecanismul care va fi folosit pentru definirea zonelor critice. Un fir poate fi setat ca fiind demon, înainte de lansarea sa în execuţie, folosind metoda: public final void setdaemon(boolean on) O aplicaţie java rulează până când: Se execută cu succes metoda exit() a clasei Runtime. Şi-au terminat execuţia toate firele nemarcate ca fiind demon. Firele pot fi grupate folosind obiecte din clasa ThreadGroup, prin folosirea unui constructor adecvat. Un grup poate să includă alte grupuri, acestea având o structură arborescentă, relaţiile între grupuri fiind de genul părinte-copil. Un fir poate avea acces la informaţiile legate de propriul grup, dar nu la informaţiile legate de alte grupuri, aici incluzându-se şi părintele. Dacă nu se specifică un anumit grup la crearea obiectului din clasa Thread, acesta va fi considerat ca făcând parte din grupul implicit.

3 Mecanisme de Sincronizare 1 Cea mai simplă metodă de sincronizare constă în folosirea unei metode join: 1. public final void join() throws InterruptedException 2. public final void join(long millis) throws InterruptedException 3. public final void join(long millis, int nanos) throws InterruptedException Prima metodă aşteaptă terminarea respectivului fir de execuţie, a doua aşteaptă cel mult millis milisecunde iar cea de-a treia mai aşteaptă şi nanos nanosecunde. Dacă firul a fost întrerupt de un altul este aruncată o excepţie InterruptedException, după care fanionul corespunzător este resetat. Un exemplu de utilizare al acestei metode este următorul, care adună elementele unui vector: /* * advector.java * * Created on 01 aprilie 2002, 14:19 */ /** * st */ public class advector extends Thread { static int v[]=new int[100];//vectorul pe care îl adunăm static int rez[]=new int[4];//aici memorăm rezultatele produse de fire private int index;//indexul firului de execuţie /** Creates new advector */ public advector(int numar) {//iniţializăm indexul firului de execuţie index=numar; public void run()//asta-i firul { int i; rez[index]=0; 1 În această lucrare este prezentat un rezumat. Pentru o descriere exhaustivă vă recomand Java Language Specification, cel puţin: volatile Fields synchronized Methods The synchronized Statement 17 Threads and Locks

4 for(i=index*25;i<(index+1)*25;i++)//algoritm clasic dar nu lucrează decât cu o parte din rez[index]+=v[i]; //vector /** args the command line arguments */ public static void main (String args[]) { int i; for(i=0;i<100;i++)//iniţializăm vectorul v[i]=i+1; advector fire[]=new advector[4]; for(i=0;i<4;i++) fire[i]=new advector(i); //creăm cele patru fire de execuţie for(i=0;i<4;i++) fire[i].start();//le pornim int suma=0; for(i=0;i<4;i++)//adunăm rezultatele produse de fire { try{ fire[i].join();//aşteptăm să moară firul i catch(interruptedexception ie) { suma+=rez[i];//adunăm System.out.println(suma); Fiecare fir de execuţie păstrează o copie de lucru pentru fiecare variabilă cu care lucrează, variabilele fiind partajate în memoria principală. În timpul execuţiei unui fir, acesta operează asupra acestor copii de lucru, memorate în memoria de lucru. Cel mai simplu mod în care se poate obţine o sincronizare între memoria de lucru şi memoria principală constă în declararea unei variabile ca fiind volatile 2. În cazul unei variabile declarate ca fiind volatile firul de execuţie trebuie să-şi armonizeze copia de lucru cu copia principală de fiecare dată când accesează variabila. În plus, operaţiile efectuate în memoria principală în numele unui fir asupra uneia sau a mai multor variabile volatile sunt executate în aceeaşi ordine în care le-a cerut firul de execuţie. Un mecanism mai sigur de sincronizare este dat de folosirea synchronized. O metodă declarată synchronized nu se va executa decât atunci când firul respectiv este "proprietarul" obiectului asociat metodei, la final obiectul fiind eliberat. În cazul unei 2 Acelaşi specificator este prezent şi în C, dar funcţionalitatea acestuia este asigurată de compilator, ceea ce face ca mecanismul să nu fie prea sigur în cazul în care există mai multe procesoare.

5 metode nestatice, se încearcă blocarea exemplarului a cărui metodă sincronizată este apelată. În cazul unei metode statice, se încearcă blocarea obiectului Class. Mecanismul este similar cu cel al mutexului, deşi este de fapt o extensie a monitorului. Exemplu: class Test { int count; synchronized void bump() { count++; static int classcount; static synchronized void classbump() { classcount++; Aceeaşi semnificaţie se poate obţine folosind instrucţiunea synchronized: class BumpTest { int count; void bump() { synchronized (this) { count++; static int classcount; static void classbump() { try { synchronized (Class.forName("BumpTest")) { classcount++; catch (ClassNotFoundException e) {... În cazul unei instrucţiuni de genul: synchronized ( Expression ) Block mai întâi se evaluează expresia care trebuie să aibă ca rezultat o referinţă non-nulă, după care se aşteaptă blocarea obiectului conţinut de referinţă, putându-se apoi trece la execuţia blocului de instrucţiuni, iar în final se efectuează deblocarea. Deoarece acest mecanism nu este suficient, în clasa Object avem câteva metode care pot fi folosite pentru sincronizare: 1. public final void wait() throws InterruptedException

6 2. public final void wait(long timeout) throws InterruptedException 3. public final void wait(long timeout, int nanos) throws InterruptedException 4. public final void notify() 5. public final void notifyall() Metodele wait fac ca firul apelant să aştepte până când un alt fir apelează metoda notify() sau notifyall() pentru acelaşi obiect sau, după caz, a expirat timpul specificat. Firul apelant al acestor metode trebuie să fie proprietarul monitorului obiectului căruia i se apelează metoda wait. Firul eliberează monitorul şi aşteaptă să fie notificat sau expirarea timpului după care aşteaptă reblocarea monitorului înainte de a continua execuţia. Metoda notify() "trezeşte" cel mult un fir, alegându-l în mod arbitrar atunci când sunt mai multe cele care aşteaptă după acelaşi obiect. Dacă doriţi să le deblocaţi pe toate, folosiţi metoda notifyall(). Mecanismul este similar cu variabilele condiţie de la Linux, de aceea wait poate fi folosit într-un context similar cu următorul: synchronized(exemplar){. exemplar.wait(); Probleme Propuse. 1. Să se determine dacă un element apare într-un vector oarecare, folosind n procesoare. 2. Să se determine pe ce poziţii apare un element într-un vector oarecare, folosind n procesoare. 3. O resursă poate fi utilizată de două tipuri de procese: albe şi negre. Atunci când resursa este folosită de procese albe ea nu mai poate fi folosită de procese negre. Este valabilă şi reciproca. Să se implementeze accesul la resursă, evitându-se înfometarea. 4. Să se sorteze elementele unui vector cu n procesoare. 5. Să se genereze toate numerele prime mai mici decât o anumită valoare, folosind n procesoare. 6. Să se coordoneze semafoarele de la capătul unui tunel cu o singură bandă, folosindu-se de senzorii de la fiecare capete care semnalizează intrarea şi ieşirea maşinilor, astfel încât să nu se permită intrarea pe la un capăt cât timp mai sunt maşini în tunel mergând în sens invers. Maşinile să fie simulate cu ajutorul firelor de execuţie.