SwRTc – Laborator
Fire de executie (threads) Java
1. Introducere in fire de executie
Programele de calcul
simple sunt secventiale, fiecare
avand un inceput, o secventa de executii
si un sfarsit. In orice moment pe durata executiei unui astfel de program exista un singur punct de executie.
Un fir de executie (thread), sau mai simplu, un fir, este similar acestor programe secventiale, in sensul ca are
un inceput, o secventa de executii si un
sfarsit, si in orice moment pe durata executiei firului exista un singur punct de executie.
Totusi, un fir nu este el insusi un
program, deoarece nu poate fi
executat de sine statator. In schimb, firul
este executat (ruleaza) intr-un
program. Relatia dintre un program si un fir de executie este ilustrata mai
jos.
Un fir de executie (thread) poate fi definit ca un flux de control secvential in cadrul
unui program. Posibilitatea utilizarii
mai multor fire de executie intr-un singur program, ruland (fiind
executate) in acelasi timp si realizand diferite sarcini (nu in mod necesar
diferite), este numita multithreading. Un navigator (browser) Web este un exemplu de aplicatie multi-filara (multithreaded).
In browser se poate parcurge pagina in timpul descarcarii unei miniaplicatii Java
(applet) a unei imagini, etc.
O denumire alternativa a firelor de executie este de lightweight process, deoarece un fir este similar unui proces
real in sensul ca ambele sunt fluxuri de control secventiale. Totusi, un fir este considerat lightweight deoarece el ruleaza in contextul unui program si are la
dispozitie reursele alocate pentru acel program si mediul programului.
Ca flux de control secvential, un fir de executie utilizeaza o parte din
resursele programului in care ruleaza. De exemplu, el trebuie sa aiba
propria stiva de executie si propriul contor de program. Codul firului de
executie lucreaza doar in acel context. De aceea, o denumire alternativa este aceea de context de executie.
Masina virtuala Java, JVM (Java Virtual Machine), permite aplicatiilor sa aiba mai multe fire
de executie care ruleaza in mod concurent (in paralel).
Fiecare fir de executie are un anumit nivel de prioritate.
Firele cu nivel de prioritate mai mare sunt executate inaintea celor cu nivel
de prioritate mai mic. Atunci cand codul care ruleaza intr-un fir de executie
creaza un nou obiect de tip Thread, noul fir de executie are initial acelasi
nivel de prioritate cu firul de executie care l-a creat.
Fiecare fir de executie are un nume, cu scopul identificarii lui. Daca nu este specificat un nume in
momentul constructiei (initializarii) firului, un nou nume (aleator stabilit) este generat.
1. Principalii
constructori ai clasei Thread:
|
Thread()
Initializeaza un
nou obiect de tip Thread (care trebuie sa implementeze metoda run())
|
|
Thread(Runnable target)
Initializeaza un
nou obiect de tip Thread caruia i se specifica un obiect tinta target
(care trebuie sa implementeze metoda run()) dintr-o clasa
care implementeaza interfata Runnable.
|
|
Thread(Runnable target, String name)
Initializeaza un nou
obiect de tip Thread caruia i se specifica un obiect tinta target
dintr-o clasa care implementeaza interfata Runnable, si un nume name.
|
|
Thread(String name)
Initializeaza un
nou obiect de tip Thread caruia i se specifica un nume name.
|
|
Thread(ThreadGroup group,
Runnable target)
Initializeaza un
nou obiect de tip Thread caruia i se specifica un obiect tinta target
dintr-o clasa care implementeaza interfata Runnable, grupul de
fire de care apartine group.
|
|
Thread(ThreadGroup group,
Runnable target, String name)
Initializeaza un
nou obiect de tip Thread caruia i se specifica un obiect tinta target
dintr-o clasa care implementeaza interfata Runnable, grupul de
fire de care apartine group, si un nume.
|
|
Thread(ThreadGroup group,
Runnable target, String name, long stackSize)
Initializeaza un
nou obiect de tip Thread caruia i se specifica un obiect tinta dintr-o clasa care
implementeaza interfata Runnable, grupul de fire de care apartine, un nume, si dimensiunea stivei
care ii va fi alocata pentru executie (stack size).
|
|
Thread(ThreadGroup group,
String name)
Initializeaza un
nou obiect de tip Thread caruia i se specifica grupul de fire de care apartine group, si
un nume name.
|
2. Declaratiile si
descrierea catorva metode ale clasei Thread:
|
int
|
activeCount()
Returneaza
numarul firelor de executie active din grupul curent de fire.
|
|
void
|
checkAccess()
Determina daca firul
curent executat are permisiunea de a modifica firul de executie curent (this).
|
|
static Thread
|
currentThread()
Returneaza o
referinta catre obiectul Thread curent executat.
|
|
void
|
destroy()
Distruge firul de
executie curent (this), fara
eliberarea resurselor.
|
|
static void
|
dumpStack()
Afiseaza
informatiile din stiva ale firului de executie curent.
|
|
static int
|
enumerate(Thread[] tarray)
Copiaza in
tabloul specificat ca parametru referinte catre toate firele de executie
active din grupul de fire curent si din subgrupurile sale.
|
|
ClassLoader
|
getContextClassLoader()
Returneaza
obiectul context al firului de executie curent.
|
|
String
|
getName()
Returneaza numele
firului de executie curent.
|
|
int
|
getPriority()
Returneaza
nivelul de prioritate al firului de executie curent.
|
|
ThreadGroup
|
getThreadGroup()
Returneaza grupul
de fire caruia ii apartine firul de executie curent.
|
|
static boolean
|
holdsLock(Object obj)
Returneaza true daca
firul de executie curent detine lock-ul monitorului creat pe obiectul
specificat ca parametru.
|
|
void
|
interrupt()
Intrerupe firul
de executie curent.
|
|
static boolean
|
interrupted()
Verifica daca
firul de executie curent executat a fost intrerupt.
|
|
boolean
|
isAlive()
Verifica daca
firul de executie curent este in viata.
|
|
boolean
|
isDaemon()
Verifica daca
firul de executie curent este fir daemon.
|
|
boolean
|
isInterrupted()
Verifica daca
firul de executie curent a fost intrerupt.
|
|
void
|
join()
Asteapta pana
cand firul de executie curent moare.
|
|
void
|
join(long millis)
Asteapta cel
putin valoarea specificata ca parametru, in milisecunde, pana cand firul de
executie curent moare.
|
|
void
|
join(long millis, int nanos)
Asteapta cel
putin millis
milisecunde plus nanos nanosecunde pana cand firul de executie curent moare.
|
|
void
|
run()
Implicit metoda
nu executa nimic si returneaza.
|
|
void
|
setContextClassLoader(ClassLoader cl)
Stabileste
obiectul context al firului de executie curent.
|
|
void
|
setDaemon(boolean on)
Marcheaza firul
de executie curent ca fir daemon.
|
|
void
|
setName(String name)
Schimba numele
firului de executie curent cu cel specificat ca parametru.
|
|
void
|
setPriority(int newPriority)
Stabileste
nivelul de prioritate al firului de executie curent.
|
|
static void
|
sleep(long millis)
Forteaza firul de
executie curent executat sa cedeze temporar executia, pentru numarul de
milisecunde specificat.
|
|
static void
|
sleep(long millis, int nanos)
Forteaza firul de
executie curent executat sa cedeze temporar executia, pentru numarul de
milisecunde plus numarul de nanosecunde specificat.
|
|
void
|
start()
Forteaza firul de
executie curent sa isi inceapa executia. Masina virtuala Java apeleaza metoda
run() a firului de executie curent.
|
|
void
|
stop()
Deprecated. Metoda este in mod inerent nesigura. In
majoritatea cazurilor utilizarea stop() poate fi inlocuita cu un cod care modifica o anumita
variabila care indica faptul ca firul de executie tinta trebuie sa isi
incheie executia, firul de executie tinta urmand sa verifice variabila in mod
regulat si sa returneze din metoda sa run() atunci cand variabila indica
necesitatea de a se incheia executia. Daca firul de executie tinta asteapta
pentru perioade lungi de timp, atunci trebuie utilizata metoda interrupt() pentru a intrerupe asteptarea.
|
|
void
|
stop(Throwable obj)
Deprecated. Vezi
explicatia de mai sus
|
|
String
|
toString()
Returneaza o
reprezentare ca sir de caractere a firului de executie curent, incluzand
numele, prioritatea, si grupul de fire ale firului de executie curent.
|
|
static void
|
yield()
Forteaza firul de
executie curent executat sa se opreasca temporar si sa permita altui fir de
executie sa fie executat.
|