Multithreaded Programming
in Java
Tonea Vlad
&
Turloi Andrei
Info 3.2.1
Task-uri si Thread-uri
• Un task reprezinta abstractizarea pasilor ce trebuie urmati in vederea
indeplinirii unor cerinte
Un task se poate face separate de catre Main Thread, pentru a nu-I afecta
performanta
Librariile din Java folosesc interfata Runnable pentru a putea rula un Task
Task-ul se poate activa prin metoda run()
• Un thread reprezinta clasa Java prin care se pot efectua mai multe fire
de executie, dupa cum ii spune si numele( thread = fir )
Acesta executa ceea ce dorim tot prin metoda run()
Cum se creeaza un Task si un Thread
• Atunci cand cream un Thread, il putem porni folosind metoda start()
Cand se apeleaza start(), aceasta este marcata ca fiind capabila sa fie rulata,
nefiind obligatoriu sa inceapa literalmente instant din momentul apelarii datorita
posibilelor prioritati mai mari ale altor thread-uri deja in functiune
Cand va porni, acesta va executa automat codul din metoda run()
• Crearea unui thread pentru toate versiunile Java se poate face prin
urmatorul mod( datorita compatibilitatii cu versiunile mai vechi, aceasta
a devenit o varianta deprecated, nefiind recomandata):
Se defineste o clasa care extinde clasa Thread( ex: MyThread )
Se defineste metoda run()
Se construieste obiectul MyThread si apeleaza start() atunci cand vrem sa o
pornim
Codul arata astfel:
• La prima vedere, tindem sa credem
ca acest cod va crea 3 thread-uri
si va tine evidenta numarului
acestora in variabila static it, adica 3
Dar nu este chiar asa…
• Rezultatul iteratorului apare ca fiind 0, desi
este impartasit( shared ) de catre toate instantele
clasei MyThread prin intermediul cuvantului static.
De ce?
• Datorita fenomenului des intalnit in multi threading, anume data race. Fiecare thread are propria sa
memorie foarte rapida dar limitata ca spatiu, numita cache; fiecare isi copiaza din memoria globala sau
shared valoarea variabilei it in cazul acesta si efectueaza operatii asupra variabilei, in paralel,
nemaisincronizandu-se cu memoria shared. De aceea vedem valoarea lui it ca fiind inca 0.
Memorie shared: static int it = 0;
Cache Cache Cache
MyThread[0] MyThread[1] MyThread[2]
propriul it care propriul it care propriul it care
devine 1 prin ++it devine 1 prin ++it devine 1 prin ++it
Cum se poate repara?
• Adaugand un obiect care joaca
rolul de lock( lacat ) asupra portiunii
de cod care ruleaza: acesta este
sincronizat cu restul thread-urilor,
adica fiecare thread trebuie sa astepte pana ce thread-ul current
termina de executat.
Runnable
• Este metoda recomandata pentru a putea folosi eficienta multi
threading-ului datorita faptului ca adauga reuzabilitate codului spre
deosebire de clasa Thread, Runnable fiind o interfata, dand
posibilitatea extinderii altor clase.
Se creeaza o clasa care implementeaza interfata Runnable cu metoda run()
Se creeaza un obiect de tip Thread avand ca parametru obiectul instantiate
de clasa respectiva
Functioneaza!
• De data aceasta, functioneaza din
prima datorita evitarii problemei
de sincronizare.
“Manager” de Thread-uri
• Daca tot cream si cream o multitudine de task-uri, le asociem cu
Thread-uri si le pornim, apar niste probleme pe care trebuie sa ni le
punem:
Daca exista prea multe threaduri?
Cate pot rula in paralel?
Se pot opri toate deodata?
Daca vreuna esueaza, se poate reporni?
Executori
• Un Executor este un obiect care administreaza task-urile care ruleaza
Se creeaza un astfel de obiect la care se trimit obiecte de tip Runnable prin
intermediul metodei execute()
Deci in loc sa cream un Thread pentru un obiect de tip Runnable, putem:
Construim sau preluam un executor deja existent( ex: exec )
Cream un obiect Runnable( ex: myTask )
Il trimitem executorului( ex: [Link]( myTask ) )
Cum preluam un Executor
• Folosim metode statice in libraria de Executori
• Folosim o “resursa” de thread-uri fixata: sa poata rula maxim N
thread-uri deodata
Executor exec = [Link](MAX_THREADS);
• Folosim un numar nelimitat de thread-uri
Executor exec = [Link]();
Executorul va arata astfel:
Race condition
• Am crede ca daca am reparat o eroare de tip data race, totul este in
regula. Dar nu este chiar asa. Sa aruncam o privire asupra
urmatoarelor linii de cod:
• Intr-adevar, cu acel
lock in metoda run(),
numarul de thread
-uri o sa fie 3, iar pe
ecran o sa se afiseze
2 pentru ca incepem
de la 0. Dar oare
daca afisam si
numele acestora,
o sa mai fie in ordine?
Aparent nu…
• Desi numarul de thread-uri este
sincronizat corect, asta nu inseamna
ca se vor executa in ordinea in care dorim.
Dupa cate se vede, daca rulam de mai multe ori, observam ca ordinea
este aleatoare.
Cum reparam?
• Ceea ce este de facut consta in
adaugarea lui [Link]() pentru a
putea pune o pauza intre thread-uri.
Acest lucru aduce un mic dezavantaj
atunci cand trebuie viteza foarte mare
de procesare deoarece metoda join
asteapta ca thread-ul curent sa se
termine, ceea ce cauzeaza un blocaj.
Se poate folosi si metoda join cu un
timp specificat in milisecunde pentru a
astepta doar o anumita durata. Alternativ,
se mai pot folosi wait() si notify(), dar acestea
trebuie folosite dintr-un context sincronizat spre deosebire
de join, altfel ni se va arunca o eroare.
Sfarsit
• Exercitii propuse:
Rulati exemplele din aceasta prezentare si observati cum functioneaza.
Alcatuiti un sistem care sa execute/proceseze un set mare de date intr-un
timp cat mai scurt.