1213 Threads [2] Programació concurrent
-
Upload
oriol-torres -
Category
Documents
-
view
289 -
download
4
description
Transcript of 1213 Threads [2] Programació concurrent
PROGRAMACIÓ CONCURRENT
Recursos per la concurrència
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
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.
PER QUÈ ÉS NECESSÀRIA LA PROGRAMACIÓ CONCURRENT?
PLATAFORMA D’EXECUCIÓ CONCURRENT
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.
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ó.
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.
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.
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ó.
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..
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
ESTATS D’UN PROCÉS
ESTATS D’UN PROCÉS EN UN ENTORN MULTIPROCÉS
Diagrama bàsic d’estats d’un procés en temps real
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
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.
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.
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.
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.
CREACIÓ DEL FILS La classe Thread
class classeConcurrent extends Thread { // .. Mètodes // .. Atributs
public void run () { // .. Sentències // .. Sentències
class ElMeuPrograma { public static void main (String [] args) { classeConcurrent tasca1, tasca2; tasca1=new classeConcurrent (); tasca2=new classeConcurrent (); // .. Més sentències tasca1.start(); tasca2.start(); // .. Més sentències
Aquesta és la tasca que serà CONCURRENT
Declaració i creació d’objectes (NORMAL)
Iniciar tasca1 concurrentment amb main (). Invocar a tasca1.run() i tornar immediatament.
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)
CREACIÓ DEL FILS La classe Thread – Exemple: Fil
class Fil extends Thread { public fil (String str) { super (str) // invoquem directament al constructor }
public void run () { for (int i = 0; i <10; i++) { System.out.println (i+” “+getName()); try { sleep ((long) (Math.random() *1000); } catch (InterruptedExecution e) {} }
System.out.println (“Fi “+getName ());
} }
La classe de la que els objectes han de ser concurrents
La tasca que serà concurrent
Atura l’execució del fil (“dorm”)
CREACIÓ DEL FILS La classe Thread – Exemple: Test
public class VarisFils {
public static void main (String [] args) { fil u, dos; //s’intstancia el Thread
u=new fil (“Hobitton”); dos=new fil (“Mordor”); //Inicia el que tingui el seu mètode run()
u.start(); dos.start(); System.out.println (“main no fa res”); }
}
Pas 1: Creo de la classe que llençarà els fils
Pas 2: Invoco a l’operador new per crear els fils
Pas 3: Invoco al mètode start () de cada fil. Aquest mètode arrenca el fil e invoca el mètode run().
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().
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.
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
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()
CICLE DE VIDA D’UN FIL Transició entre estats d’un thread