Dekker Peter Jar Des Qui

REPORTE DE ALGORITMOS (PETERSON DEKKER, JARDINES Y ESQUIMALES)
Benemrita Universidad Autnoma de Puebla

Facultad de Ciencias de la Computacin
Programacin Concurrente y Paralela
Ma. Carmen Cern Garnica

Alumnos: Yimi Molina Heredia.
Lidia Hernndez Andrade.
Ricardo Contreras Cervantes.
Cesar Eduardo Guerra Gonzlez.

OBJETIVO: Analizar el problema de exclusin mutua de procesos en
sistemas con memoria en comn de procesos ejecutndose
concurrentemente para acceder a un mismo recurso compartido.

******Cdigo fuente Peterson******

Este algoritmo es un medio para conseguir la exclusin mutua
generalizada para N procesos, que utiliza variables comunes a los procesos
concurrentes que solo pueden tomar un numero acotado de valores.

//archivo del algoritmo de Peterson

class ComunPeterson
{
int procesofavorecido = 1;
boolean P1deseaEntrar =false;
boolean P2deseaEntrar =false;

Lista I = new Lista();
}

class PetersonP1 extends Thread
{
ComunPeterson cp;

public PetersonP1(ComunPeterson cp)
{
this.cp =cp;
cp.I.insertarDato(new Integer(0));
}

public void run()
{
int i=0;
int j=0;

while(j<21)
{
cp.P1deseaEntrar=true;
try{
sleep(400);
}
catch(Exception e){}
while((cp.P2deseaEntrar)&&(cp.procesofavorecido==1))
{
cp.I.insertarDato(new Integer(i+1));
System.out.println("\nEl algoritmo de Peterson inserto el #"+(i));

cp.procesofavorecido=2;
cp.P1deseaEntrar=false;
}
i++; j++;
}
}
}

{
ComunPeterson cp;
public PetersonP2(ComunPeterson cp)
{
this.cp=cp;
}

public void run()
{
int i=0;
int j=0;
boolean inicio =true;

while (j<20)
{
cp.P2deseaEntrar = true;
try{
sleep(400);
}

while((cp.P1deseaEntrar)&&(cp.procesofavorecido==2))
{
if(inicio) cp.I.iniciarAuxiliar();
inicio=false;

System.out.println("\tEl Algoritmo Peterson tomo el #"+(cp.I.obtenerDato()));

cp.procesofavorecido = 1;
cp.P2deseaEntrar=false;
}
i++; j++;
}
}
}

class MainPeterson
{
public static void main(String a[])
{
ComunPeterson cp =new ComunPeterson();

cp.procesofavorecido=1;
cp.P1deseaEntrar = false;
cp.P2deseaEntrar = false;

PetersonP1 p1=new PetersonP1(cp);
PetersonP2 p2=new PetersonP2(cp);

System.out.println("\n\t\tAlgoritmo de PETERSON\n");

p1.start();
p2.start();
}
}

CORRIDA

*****Cdigo fuente Dekker*****
Este algoritmo es una combinacin de los intentos que Dr. Dekker realizo, haciendo una
combinacin del primero y el cuarto intento; en donde las variables individuales de los
procesos permiten conseguir la exclusin mutua, pero se usa una variable de turno comn
para ambos proceso.

//Archivo del algoritmo de Dekker

class ComunDekker
{
int favorecido;
boolean p1quiereEntrar, p2quiereEntrar;

int noLineas;
}

class P2Dekker extends Thread
{
ComunDekker cd;
int i;
public P2Dekker(ComunDekker cd, int i)
{
this.cd = cd;
this.i = i;
}

public void run()
{
int j=0;
while(j<15)
{
cd.p2quiereEntrar = true;
while(cd.p1quiereEntrar)
{
cd.p2quiereEntrar = false;
while (cd.favorecido == 1);
}
if(cd.favorecido==2)
{
System.out.println("PROCESO DEKKER2 GENERO EL
#"+(cd.noLineas+1));
cd.noLineas++;
}
cd.favorecido =1;
j++;
}
}
}

{
ComunDekker cd; int i;

{
this.cd = cd;
this.i = i;
}
public void run()
{
int j=0;
while(j<15)
{
{
}
{
System.out.println("PROCESO DEKKER1 GENERO EL
#"+(cd.noLineas+1));
cd.noLineas++;
}
cd.favorecido =2;
j++ ;
}
}
}

class MainDekker
{
{
ComunDekker cd = new ComunDekker();
cd.favorecido = 1;
cd.noLineas = 0;

System.out.println("\n\t\tAlgoritmo de Dekker\n");

for (int i=0; i<10; i++)
{
new P1Dekker(cd,i).start();
}
}
}

CORRIDA

***** Cdigo Fuente Jardines *****
Problema de los jardines: se tienen dos puertas para la visita de unos
jardines. La entrada y la salida de los jardines se pueden realizar por dos
puntos que disponen de dos puertas. En donde la variable comn se utiliza
como cauce de comunicacin entre los distintos procesos, con el objetivo de
acceder stos a sus regiones criticas con cierto orden.

class ComunDekker
{
int favorecido;
boolean p1quiereEntrar, p2quiereEntrar;

}

{
ComunDekker cd;
int i;
{
this.cd = cd;
this.i = i;
}

public void run()
{
int j=0;
while(j<3)
{
{
}
{
System.out.println("Estan entrando visitantes por la puerta 2");
System.out.println("Estan saliendo por la puerta 1");
}
cd.favorecido =1;
j++;
}
}
}

{
ComunDekker cd; int i;

{
this.cd = cd;
this.i = i;
}
public void run()
{
int j=0;
while(j<3)
{
{
}
{
System.out.println("Estan entrando visitantes por la puerta 1");
System.out.println("Estan saliendo por la puerta 2");
}
cd.favorecido =2;
j++ ;
}
}
}

class MainJardines
{
{
ComunDekker cd = new ComunDekker();
cd.favorecido = 1;

System.out.println("\n\t\tAlgoritmo de Dekker\n");

for (int i=0; i<10; i++)
{
}
}
}


CORRIDA


***** Cdigo Fuente Esquimales *****
Problema de los esquimales: solo uno de los esquimales puede acceder a la vez al
pizarrn y cuando uno delos esquimales quiere acceder al agujero para pescar debe
consultar si tiene permiso par hacerlo; si el permiso lo tiene otro esquimal esperara un
tiempo, cuando se le indique que tiene permiso entonces este podr ir a pescar.

class Nodo
{
Object dato;

Nodo liga;

public Nodo(Object x)
{
dato=x;
liga=null;
}
}

class Lista
{
Nodo Inicio, actual;

Lista()
{
Inicio=null;
}
void insertarDato(Object x)
{
Nodo aux;
if(this.Inicio==null)
{
Inicio =new Nodo(x);
}
else
{
aux=this.Inicio;
while(aux.liga !=null)
aux = aux.liga;
aux.liga =new Nodo(x);
}
}

Object obtenerDato()
{
Nodo aux;

if(actual==null)
return null;
else
aux=actual;
actual=actual.liga;
return aux.dato;
}

void iniciarAuxiliar()
{
actual =this.Inicio;
}
}

{
ComunPeterson cpescar;

public PetersonP1(ComunPeterson cpescar)
{
this.cpescar =cpescar;
cpescar.I.insertarDato(new Integer(0));
}

public void run()
{
int i=0;
int j=0;

while(j<20)
{
cpescar.P1deseaPescar=true;
try{
sleep(400);
}
while((cpescar.P2deseaPescar)&&(cpescar.procesofavorecido==1))
{
cpescar.I.insertarDato(i+1);
System.out.println("\n El esquimal #"+ (i+1) + " esta pescando");

cpescar.procesofavorecido=2;
cpescar.P1deseaPescar=false;
}
i++; j++;
}
}
}

{
ComunPeterson cpescar;
public PetersonP2(ComunPeterson cpescar)
{
this.cpescar=cpescar;
}

public void run()
{
int i=0;
int j=0;
boolean inicio =true;

while (j<20)
{
cpescar.P2deseaPescar = true;
try{
sleep(400);
}

while((cpescar.P1deseaPescar)&&(cpescar.procesofavorecido==2))
{
if(inicio) cpescar.I.iniciarAuxiliar();
inicio=false;
System.out.println("\tEsta en la pizarra el esquimal #" +
(cpescar.I.obtenerDato()));

cpescar.procesofavorecido = 1;
cpescar.P2deseaPescar=false;
}
i++; j++;
}
}
}

////main
class ComunPeterson
{
int procesofavorecido = 1;
boolean P1deseaPescar =false;
boolean P2deseaPescar =false;

Lista I = new Lista();
}

class MainPeterson
{
{

ComunPeterson cpescar =new ComunPeterson();

cpescar.procesofavorecido=1;
cpescar.P1deseaPescar = false;
cpescar.P2deseaPescar = false;

PetersonP1 p1=new PetersonP1(cpescar);
PetersonP2 p2=new PetersonP2(cpescar);

System.out.println("\n\t\tAlgoritmo de PETERSON\n");
p1.start();
p2.start();

}
}

CORRIDA

Conclusin:
Por medio de los algoritmos anteriores se estudio el problema de exclusin mutua par n
procesos, en donde las instrucciones incluidas en las secciones criticas de los n procesos no
se ejecutan entrelazadas en cada caso todo proceso se ejecuta en su seccin critica y deber
entes entrar en ella (seccin critica) ejecutando un pre-protocolo al salir se libera a otro
proceso para ejecutar.

Reflexin:
Se aprendi a evitar problemas de exclusin mutua. Los programas anteriores se evita que
dos o ms procesos concurrentes se encuentren ejecutando su seccin crtica al mismo
tiempo.

Dekker Peter Jar Des Qui

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Dekker Peter Jar Des Qui

Uploaded by

Copyright:

Available Formats

REPORTE DE ALGORITMOS (PETERSON DEKKER, JARDINES Y ESQUIMALES)

Benemrita Universidad Autnoma de Puebla

You might also like