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