2. PER QUÈ ÉS NECESSÀRIA LA
PROGRAMACIÓ CONCURRENT?
(1) Per la utilització completa del processador
(2) Paral·lelisme entre la
CPU i els dispositius d’E/S
3. PER QUÈ ÉS NECESSÀRIA LA
PROGRAMACIÓ CONCURRENT?
(3) Per poder expressar el
paral·lelisme potencial que
existeix per fer que més d’un
ordinador es pugui utilitzar per
resoldre el problema.
Per exemple, per trobar la sortida
a un laberint.
4. PER QUÈ ÉS NECESSÀRIA LA
PROGRAMACIÓ CONCURRENT?
6. PROGRAMES CONCURRENTS I
PROCESSOS
Un programa concurrent es concep com un CONJUNT
DE THREADS o FILS DE CONTROL.
Cada THREAD executa una única activitat seqüencial.
Cada THREAD s’executa en el seu propi processador
virtual executant independentment accions d’acord
amb l’activitat que tingui associada .
Els THREADs concurrents intercanvien entre ells
missatges amb informació i missatges de sincronisme.
7. ASPECTES DELS PROCESSOS
Cada entorn de programació concurrent necessita
establir algunes característiques sobre els seus
processos:
Naturalesa dels processos.
Jerarquia dels processos.
Mecanismes de inicialització.
Mecanismes de finalització.
Formes de declaració.
8. NATURALESA DELS PROCESSOS
Els processos poden ser:
Estàtics: Són instanciats al començament del programa. El
programador es declara explícitament.
Dinàmics: Són creats durant l’execució del programa, en
funció de les dades.
En funció dels processos que poden existir en un
sistema es classifiquen com:
Sistema tancat: S’ha de tenir un coneixement en temps
disseny (estàtic) sobre els processos que construeixen en el
sistema i la seva activitat.
Sistema obert: El número de processos que constitueixen el
sistema varia en el temps de forma que no es pot predir
(fase de disseny), per exemple, perquè crea dinàmicament
processos.
9. JERARQUIA DELS PROCESSOS
Els processos d’un programa es poden organitzar en:
Estructura plana: Tots els processos són equivalents.
Evolucionen i finalitzen independentment (processos
UNIX).
Estructura jerarquitzada: Entre els processos existeixen
unes relaciones de dependència amb estructura d’arbre.
Un procés no finalitza fins que els processos que en
depenen no finalitzen.
10. INCIALITZACIÓ DELS PROCESSOS
Inicialitzar un procés és transferir-li, després de la
seva creació, la informació que requereix per
caracteritzar-lo individualment.
Existeixen diferents categories:
A UNIX, cada procés és inicialment una rèplica del seu pare.
A JAVA, en la creació s’estableixen uns paràmetres de
incialització.
Després de la creació, el fill comunica amb el seu pare i rep
la informació de incialització.
11. FINALITZACIÓ DELS PROCESSOS
Existeixen múltiples formes de finalització d’un procés:
Quan la línia de flux de control assoleix el final (amb èxit).
Quan es produeix una excepció no atesa (amb fallida).
Quan un procés executa una sentència “self terminate” (amb
fallida).
Quan el procés és avortat per un altre procés (amb fallida).
Quan es dóna una finalització coordinada “terminate” (amb
èxit).
O bé, mai..
12. DECLARACIÓ DE PROCESSOS
CONCURRENTS
Declaració per sentències estructurades
cobegin
procés_1, procés_2, .., procés_n
coend
Declaració com a components de bloc
procedure Pare;
process procés_1, begin .... end;
process procés_2, begin .... end;
begin ... End;
Bifurcació (fork)
......
{if (fork()==0)
{ ... } // Solament s’executa en el procés fill
else
{ ... } // S’executa solament en el procés pare
}
Invocació no estructurada
14. ESTATS D’UN PROCÉS EN UN ENTORN
MULTIPROCÉS
Diagrama bàsic d’estats d’un procés en temps real
15. CLASSES RELACIONADES AMB ELS FILS
El llenguatge de programació Java proporciona suport
pels fils (un fil és un únic flux d’execució dins d’un
procés) mitjançant una interfície i un conjunt de
classes.
La interfície de Java i les classes que inclouen
funcionalitat:
Threads
Runnable
Object Thread
16. CLASSES RELACIONADES AMB ELS FILS
Thread
És la classe responsable de produir fils funcionals per
altres classes.
Per afegir la funcionalitat de fil a una classe, aquesta
es deriva de Thread i s’ignora el mètode run.
La classe Thread també defineix els mètodes start i
stop.
17. CLASSES RELACIONADES AMB ELS FILS
Runnable
Java no suporta l’herència múltiple de forma directa.
Aquesta interfície proporciona la capacitat d’afegir la
funcionalitat d’un fil a una classe implementant la
interfície.
18. CLASSES RELACIONADES AMB ELS FILS
Object
No es tracta d’una classe de suport als fils.
La classe Object proporciona mètodes com wait,
notify i notifyAll.
19. CREACIÓ DEL FILS
A Java, la creació de nous fils és molt més ràpida que
la creació de nous processos.
A Java, en el procés de creació de fils, hi ha dos
mecanismes que ens permetran portar-ho a terme:
Estenent la classe Thread.
Implementant la interfície Runnable.
En ambdós casos, s’ha de definir un
mètode run.
20. CREACIÓ DEL FILS
La classe Thread
class classeConcurrent extends Thread {
// .. Mètodes Aquesta és la tasca que serà
// .. Atributs CONCURRENT
public void run () {
// .. Sentències
// .. Sentències
class ElMeuPrograma {
public static void main (String [] args) {
classeConcurrent tasca1, tasca2;
tasca1=new classeConcurrent (); Declaració i creació
tasca2=new classeConcurrent (); d’objectes (NORMAL)
// .. Més sentències
tasca1.start();
Iniciar tasca1 concurrentment
tasca2.start();
// .. Més sentències amb main (). Invocar a
tasca1.run() i tornar
immediatament.
21. CREACIÓ DEL FILS
La classe Thread - Conclusions
Un objecte concurrent pertany a una classe que estén
Thread.
S’ha de tornar a definir el mètode run () que
especifica la tasca concurrent.
L’execució de la tasca concurrent es realitza
mitjançant el mètode start () (heretat del Thread)
22. CREACIÓ DEL FILS
La classe Thread – Exemple: Fil
class Fil extends Thread { La classe de la que els objectes
public fil (String str) { han de ser concurrents
super (str) // invoquem directament al constructor
}
public void run () { La tasca que serà concurrent
for (int i = 0; i <10; i++) {
System.out.println (i+” “+getName());
try {
sleep ((long) (Math.random() *1000); Atura l’execució del fil
} catch (InterruptedExecution e) {} (“dorm”)
}
System.out.println (“Fi “+getName ());
}
}
23. CREACIÓ DEL FILS
La classe Thread – Exemple: Test
public class VarisFils {
Pas 1: Creo de la classe que
llençarà els fils
public static void main (String [] args) {
fil u, dos;
//s’intstancia el Thread
u=new fil (“Hobitton”); Pas 2: Invoco a l’operador
dos=new fil (“Mordor”); new per crear els fils
//Inicia el que tingui el seu mètode run()
u.start();
Pas 3: Invoco al mètode start ()
dos.start();
de cada fil. Aquest mètode
System.out.println (“main no fa res”); arrenca el fil e invoca el mètode
} run().
}
24. CREACIÓ DEL FILS
La interfície runnable
Implementar la interfície Runnable és un altre
mètode per construir fils.
Presenta algunes variacions: Principalment, en el
mètode main.
Per incialitzar un objecte derivat d’una classe que
implementa la interfície runnable hem de declarar
que es crearà un nou fil i que aquest s’ha
d’inicialitzar amb el mètode start().
25. CREACIÓ DEL FILS
Thread vs. Runnable
Si tots dos mètodes fan el mateix, quan haig
d’heretat de Thread i quan haig de implementar
Runnable?
Si la classe ha de ser derivada d’una altre classe (per exemple,
la classe Applet), s’utilitza el mètode runnable. En cas
contrari, senzillament, s’hereta de la classe Thread.
26. CREACIÓ DEL FILS
Thread vs. Runnable
A Java no hi ha herència múltiple: O heretes de
Thread o heretes d’Applet o de qualsevol altre classe.
class rellotge extends Applet extends Thread { }
class rellotge extends Applet implements Runnable { }
• Puc heretar d’Applet
• Puc implementar la funcionalitat dels fils
27. CREACIÓ DEL FILS
La interfície Runnable: Implementació
Consisteix en declarar una classe que implementi
Runnable i sobreescriure el mètode run()
public abstract void run()
Dins de run() incloem el codi a executar pel nou fil.
A continuació, crearem un objecte de la classe Thread
dins d’aquesta classe.
Al constructor de Thread li passem com argument l’objecte de la nova
classe (instància d’una classe que implementi Runnable):
Thread(Runnable objecteFil, String nomFil)
Per últim, cridem al métode start() amb l’objecte
anterior.
Synchronized void start()
28. CICLE DE VIDA D’UN FIL
Transició entre estats d’un thread
