Transcript c10

Programare Orientata Obiect
Curs 10
Fire de executie
4/13/2015
Curs 10
1
Continutul cursului
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
Introducere
Platforma Java, Clase si Obiecte
Modificatori, Constructori
Pachete. Incapsularea datelor
Mostenirea / Extinderea claselor
Conversii de date. Clase si metode abstracte
Interfete
Exceptii (I)
Exceptii (II)
Fire de executie
4/13/2015
Curs 10
2
Curs 10
1. Fire de executie
1.1 Multitasking si multithreading
1.2 Concurenta si paralelism
1.3 Utilitatea firelor de executie
1.4 Application Thread
1.5 Implementarea firelor de executie
1.6 Planificarea executiei
1.7 Prioritatea firelor de executie
1.8 Exemple
4/13/2015
Curs 10
3
C10. Fire de executie
1.1 Multitasking si multithreading
– Multitasking
– Se refera la capacitatea unui sistem de calcul de a
rula mai multe aplicatii in acelasi timp
– Multithreading
– Un fir de executie (thread) reprezinta o succesiune
de operatii din cadrul unei aplicatii
– Multithreading – capacitatea de a executa mai multe
operatii in acelasi timp in cadrul aceleiasi aplicatii
C10. Fire de executie
1.2 Concurenta si paralelism
CPU
CPU1
CPU2
C10. Fire de executie
1.3 Utilitatea firelor de executie
– Pentru a realiza aplicatii care sa fie capabile sa
interactioneze cu utilizatorii in timp ce efectueaza
operatii de durata
– Pentru a permite oprirea unor operatii
– Pentru probleme ce implica o rezolvare “paralela”
– Pentru a monitoriza starea unor resurse (de exemplu o
baza de date)
– Pentru implementarea API-urilor
C10. Fire de executie
1.4 Application Thread
– Cand se executa o aplicatie Java:
1. JVM creaza un fir de executie (principal) pentru a
rula instructiunile din metoda main()
2. JVM porneste firul de executie
3. Firul de executie ruleaza intructiunile din program
una cate una
4. Dupa ce se ruleaza toate instructiunile firul de
executie “moare”
C10. Fire de executie
1.4 Application Thread
– Pe langa firul principal de executie se pot crea si altele
– Fiecare fir de executie are propria sa zona de memorie
– Daca doua fire de executie ruleaza aceeasi metoda,
fiecare va avea propria copie a variabilelor locale pe care
le foloseste metoda
– Doua fire de executie pot actiona asupra aceluiasi obiect
sau asupra campurilor statice in mod concurent
C10. Fire de executie
1.5 Implementarea firelor de executie
– Exista doua modalitati de a crea fire de executie (obiect
de tip Thread):
1. Prin mostenirea clasei Thread si instantierea unui
obiect din subclasa
2. Prin implementarea interfetei Runnable
– In ambele cazuri trebuie implementata metoda run()
C10. Fire de executie
1.5 Implementarea firelor de executie
– Implementarea firelor de executie pornind de la clasa Thread
public class ThreadExample extends Thread {
public void run () {
for (int i = 1; i <= 100; i++) {
System.out.println(“---”);
}}}
– Metodele clasei Thread:
– void start() – creaza un nou fir de executie si il pregateste pentru
rulare; poate fi apelata doar o singura data pentru un fir de executie
– void run() – lanseaza firul de executie
– void stop() – firul de executie este oprit
– void yield() - provoaca oprirea temporara a firului de executie curent
pentru a permite executarea altor fire de executie cu prioritate mai
mare
– void sleep(int m) – permite oprirea firului de executie pentru m
milisecunde
C10. Fire de executie
1.5 Implementarea firelor de executie
– Implementarea firelor de executie folosind interfata Runnable
public class RunnableExample implements Runnable
{
public void run () {
for (int i = 1; i <= 100; i++) {
System.out.println(“***”);
}}}
– Cand folosim interfata Runnable se creaza un obiect de tip Thread
din obiectul Runnable
– Metoda run() din obiectul Thread apeleaza metoda run() din
obiectul Runnable
– Important! Aceasta modalitate de a crea fire de executie se poate
folosi pentru clasele derivate (care deja mostenesc o alta clasa).
C10. Fire de executie
1.5 Implementarea firelor de executie
– Pornirea firelor de executie:
public class ThreadsStartExample {
public static void main (String argv[]) {
new ThreadExample().start ();
new Thread(new RunnableExample()).start ();
}
}
– Rezultatul?
“---------------------------------------***----------------------------------***-------------------------***--------------***-------------***------**********************************
*************************************************************
****************************************”
C10. Fire de executie
1.6 Planificarea executiei
start()
Coada de asteptare
Fire de executie
nou create
Firul de executie
Aflat in rulare
Operatia I/O finalizata
Coada de asteptare pentru operatiile I/O
C10. Fire de executie
1.7 Prioritatea firelor de executie
– Fiecare fir de executie are o prioritate
– Atunci cand un fir de executie este creat, mosteneste prioritatea
firului de executie din care se lanseaza noul fir
– Prioritatea unui fir reprezinta o valoare intre 1 si 10, 1 reprezentand
cea mai mica prioritate, iar 10 cea mai mare
– Prioritatea poate fi modificata prin metoda setPriority()
– Putem afla prioritatea unui fir de executie prin metoda getPriority()
– Constante ce definesc nivele de prioritate:
MIN_PRIORITY=1
MAX_PRIORITY=10
NORM_PRIORITY=5
– Firul de aplicatie principal (cel care executa main) porneste cu
prioritatea 5
C10. Fire de executie
1.8 Exemple (I)
public class PrintThread1 extends Thread {
String name;
public PrintThread1(String name) {
this.name = name;
}
public void run() {
for (int i=1; i<100 ; i++) {
try {
sleep((long)(Math.random() * 100));
} catch (InterruptedException ie) { }
System.out.print(name);
}
}
C10. Fire de executie
1.8 Exemple (I)
public static void main(String args[]) {
PrintThread1 a = new PrintThread1("*");
PrintThread1 b = new PrintThread1("-");
a.start();
b.start();
}
}
– Rezultatul?
C10. Fire de executie
1.8 Exemple (II)
class AfisareNumere extends Thread {
private int a, b, pas;
public AfisareNumere (int a, int b, int pas ) {
this .a = a;
this .b = b;
this .pas = pas;
}
public void run () {
for (int i = a; i <= b; i += pas)
System . out. print (i + " " );
}
}
public class TestThread {
public static void main ( String args []) {
AfisareNumere fir1 , fir2 ;
fir1 = new AfisareNumere (0, 100 , 5);
// Numara de la 0 la 100 cu pasul 5
fir2 = new AfisareNumere (100 , 200 , 10);
// Numara de la 100 la 200 cu pasul 10
fir1 . start ();
fir2 . start ();
// Pornim firele de executie
// Ele vor fi distruse automat la terminarea lor
}}
C10. Fire de executie
1.8 Exemple (III)
class MyRunnable implements Runnable
{ public void run()
{ while (true)
{ System.out.println ("Ruleaza " +
Thread.currentThread().getName());
try
{ Thread.sleep(2000);
}
catch (InterruptedException e)
{ }
}
}
}
C10. Fire de executie
1.8 Exemple (III)
class TestFireR
{ MyRunnable objects[];
Thread fire[];
TestFireR()
{ objects = new MyRunnable[4];
objects[0] = new MyRunnable();
objects[1] = new MyRunnable();
objects[2] = new MyRunnable();
objects[3] = new MyRunnable();
fire = new Thread[4];
fire[0] = new Thread(objects[0],"fir
fire[1] = new Thread(objects[1],"fir
fire[2] = new Thread(objects[1],"fir
fire[3] = new Thread(objects[1],"fir
fire[0].start();
fire[1].start();
fire[2].start();
fire[3].start();
1");
2");
3");
4");
}
public static void main (String args[])
{ new TestFireR();
}
}
Continutul cursului
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
Introducere
Platforma Java, Clase si Obiecte
Modificatori, Constructori
Pachete. Incapsularea datelor
Mostenirea / Extinderea claselor
Conversii de date. Clase abstracte
Interfete
Exceptii (I)
Exceptii (II)
Fire de executie
Pachetul IO
4/13/2015
Curs 10
20