BENEMRITA UNIVERSIDAD AUTNOMA DE PUEBLA

EDUCACIN MEDIA SUPERIOR

FACULTAD DE CIENCIAS DE LA COMPUTACIN

REPORTE DE LOS PROGRAMAS DE MONITORES

ALUMNOS:
MARCELA PAOLA ESTRADA GARCA
JAMELLI VAZQUEZ JUAREZ
GUSTAVO ANGEL OSORIO TELLEZ
KEVIN ESLI DIAZ ALONSO
PROFESORA:
MA. CARMEN CERN GARNICA

PROGRAMACIN CONCURRENTE Y PARALELA

OTOO 2013

MONITORES
Un monitor es una construccin sintctica de un lenguaje de programacin concurrente que
encapsula una estructura de datos o recurso que se ha de proteger mediante exclusin mutua,
junto con un conjunto de procedimientos que manejan ese recurso.
La interface del monitor con el exterior es el conjunto de llamadas a procedimientos del
monitor especificadas en su definicin. Los procesos requieren los servicios de los monitores
mediante llamadas a sus procedimientos.
La semntica de cualquier monitor es tal que slo a un proceso se le permite ejecutar uno de
los procedimientos del monitor en un instante dado, con lo que aseguramos la exclusin
mutua sobre las variables y recursos globales.
El problema de la exclusin mutua de los datos, queda automticamente resuelto por el hecho
de usar un monitor. Sin embargo, dentro del monitor puede ser necesarios en ocasiones
sincronizar a los procedimientosque lo componen. La sincronizacin a nivel interno en los
monitores se consigue utilizando las variables de condicin o seales, que son variables que
no toman ningn tipo de valor, pero tiene asociada una lista de procesos suspendidos.
Sus operaciones son:
Delay , suspende el proceso que lo ejecuta y lo incluye en la lista de una variable
Condition.
Resume, Reactiva un proceso de la lista asociada a una variable Condition.
Empty , retorna True si la lista de procesos de la variable est vaca.

Ejercicio 1.
PLANTEAMIENTO
Supongamos que queremos controlar el acceso a un parking con el siguiente comportamiento:
Cuando un coche llega al parking ste espera, espera a que la barrera de acceso al parking se
levante. La barrera slo se levantar cuando el parking no est lleno, el semforo que est
detrs est verde y la mquina de tickets ha expendido un ticket. La barrera baja cuando
detecta que el coche ha pasado. La mquina de tickets expende un ticket cuando detecta que
se ha pulsado el botn de la mquina. Cuando la barrera est levantada entonces el coche
pasa. Despus de pasar el coche, la barrera se baja. Pasado un tiempo desde que el coche
aparc, ste sale del parking.
Se consideran 4 procesos: coche, maquinaTikets, Barrera y semforo
CDIGO EN JAVA:
//clase Semaforo
publicclassSemaforo {
protectedint contador = 0;
publicSemaforo (intvalorInicial) {
contador = valorInicial;
}
synchronizedpublicvoid WAIT () {
while (contador == 0)
try {
wait();
}
catch (Exception e) {}
contador--;
}
synchronizedpublicvoid SIGNAL () {
contador = 1;
notify();
}
}
//clase Monitor
publicclass monitor {
privateSemaforomon;
public monitor() {
mon = new Semaforo(1);
}
publicvoidenter() {
mon.WAIT();
}
publicvoidexit() {
mon.SIGNAL();

}
publiccondicioncreaCond() {
return new condicion(mon);
}
}
//clase condicin
publicclasscondicion{
privateSemaforocond, mon;
privateintwaiting;
publiccondicion(Semaforomon) {
cond = new Semaforo(0);
this.mon = mon;
waiting = 0;
}
publicvoid WAIT() {
waiting++;
mon.SIGNAL();
cond.WAIT();
mon.WAIT();
}
publicvoid SIGNAL() {
if(waiting> 0) {
waiting--;
}
cond.SIGNAL();
}
publicvoidbroadcast_cond() {
for(; waiting> 0; waiting--)
cond.SIGNAL();
}
publicbooleanhas_waiting() {
returnwaiting> 0;
}
}
//programa principal parking con los procesos barra,maquinaTikets , coche
publicclass parking {
staticcarPark e;
publicstaticvoidmain(Stringargs[]) {
int i;
e = new carPark();
Coche coches[] = new Coche[10];
MaquinaTikets maquina = new MaquinaTikets(e);
Barrera barrera = new Barrera(e);

for(i=0; i<10; i++)

coches[i] = new Coche(i,e);
for(i=0; i<10; i++)
coches[i].start();
maquina.start();
barrera.start();
}
}
classcarPark {
condicionticketExpedido;
condicionSubirbarrera;
condicioncocheHaPasado;
condicionnoHayCoche;
condicionBajarBarrera;
condicionnumCoches;
condicionboton;
monitormon;
publiccarPark() {
mon = new monitor();
boton = mon.creaCond();
ticketExpedido = mon.creaCond();
Subirbarrera = mon.creaCond();
cocheHaPasado = mon.creaCond();
noHayCoche = mon.creaCond();
BajarBarrera = mon.creaCond();
numCoches = mon.creaCond();
noHayCoche.SIGNAL();
BajarBarrera.SIGNAL();
numCoches.SIGNAL();
}
publicvoidesperaPasar(int i) {
try {
Thread.sleep(1000);
}
catch(Exception e) {}
mon.enter();
System.out.println("el coche "+i+" llego");
noHayCoche.WAIT();
BajarBarrera.WAIT();
boton.SIGNAL();
Subirbarrera.WAIT();
System.out.println("Coche: "+i+" entra");
cocheHaPasado.SIGNAL();
noHayCoche.SIGNAL();
mon.exit();
try {

Thread.sleep(1000);
}
catch(Exception e) {}
mon.enter();
numCoches.SIGNAL();
System.out.println("Salio Coche: "+i);
mon.exit();
}
publicvoidpasaCoche() {
while(true) {
mon.enter();
numCoches.WAIT();
ticketExpedido.WAIT();
Subirbarrera.SIGNAL();
System.out.println("Subiendo Barra...");
cocheHaPasado.WAIT();
System.out.println("Bajando Barra...");
BajarBarrera.SIGNAL();
mon.exit();
}
}
publicvoidexpideTiket() {
while(true) {
mon.enter();
boton.WAIT();
System.out.println("Expidiendo ticket...");
ticketExpedido.SIGNAL();
mon.exit();
}
}
}
class Coche extendsThread {
int i;
carPark e;
public Coche(int _i, carPark e) {
i = _i;
this.e = e;
}
publicvoidrun() {
e.esperaPasar(i);
}
}
classMaquinaTiketsextendsThread {
carPark e;

publicMaquinaTikets(carPark e) {
this.e = e;
}
publicvoidrun() {
e.expideTiket();
}
}
class Barra extendsThread {
carPark e;
public Barra(carPark e) {
this.e = e;
}
publicvoidrun() {
e.pasaCoche();
}
}
CAPTURAS DE PANTALLA:

EJERCICIO 2
PLANTEAMIENTO:
En una sala con 30 filas de 10 asientos cada uno se realiza un congreso. La sala tiene dos
entradas por donde entran los congresistas. Suponga que existen N congresistas que cuando
llegan hacen cola en la entrada en la entrada que en ese momento tenga menos gente. En caso
que la sala est llena el congresista se va.
Hay 3 acomodadores que van ubicando de a uno a los primeros de las colas hasta que la sala
este llena o hasta que termine la conferencia. Para acomodar a los congresistas los
acomodadores buscan un asiento libre y lo dejan en la punta de la fila indicndoles su asiento,
para que luego el congresista se siente. Cuando se sentaron 40 congresistas comienza el
congreso que dura 2 ha (modelice el tiempo con la funcin delay(x) que retarda un proceso x
minutos) una vez que termina el congreso deben concluir todos los procesos. La entrada a la
conferencia no interfiere con la bsqueda de los asientos libres.
CODIGO EN JAVA:
class Monitor
{
private String cad;
privateboolean permiso1=true;
privateboolean permiso2=true;
privateboolean permiso3=true;
public Monitor()
{
cad=null;
}

public synchronized void Acomodador1 (String cad)

{
while(permiso1==false)
{
try
{
wait();
}catch (Exception e){}
}
System.out.println("Acomodador: "+Thread.currentThread().getName()+cad);
permiso1=false;
notify();
}
public synchronized void Acomodador2 (String cad)
{
while(permiso2==false)
{
try
{
wait();
}catch (Exception e){}
}
System.out.println("Acomodador: "+Thread.currentThread().getName()+cad);
permiso2=false;
notify();
}
public synchronized void Acomodador3 (String cad)
{
while(permiso3==false)
{
try
{
wait();
}catch (Exception e){}
}
System.out.println("Acomodador: "+Thread.currentThread().getName()+cad);
permiso3=false;
notify();
}
public synchronized void AsientoD (String cad)
{
while (permiso1==true)
{
try
{
wait();

}catch (Exception e){}

}
while (permiso2==true)
{
try
{
wait();
}catch (Exception e){}
}
while (permiso3==true)
{
try
{
wait();
}catch (Exception e){}
}
System.out.println("Acceso: "+Thread.currentThread().getName()+cad);
permiso1=true;
permiso2=true;
permiso3=true;
notifyAll();
}
}
classAccesoA implements Runnable
{
Monitor m;
//String name;
publicAccesoA(Monitor m)
{
this.m = m;
}
public void run()
{
for(inti=0;i<15;i++)
{
m.AsientoD(" Ingresando por Acceso A");
}
System.out.println("**Ya no hay mas congresistas**");
}
}
classAccesoB implements Runnable
{
Monitor m;
publicAccesoB(Monitor m)

{
this.m = m;
}
public void run()
{
for(int i=0;i<12;i++)
{
m.AsientoD(" Ingresando por Acceso B");
}
System.out.println("**El Congreso ha terminado**");
}
}
public class BuscaA {
int AD[][] = new int[30][10];
publicBuscaA() {
}
public void SCongreso(){
for(inti=0; i<30; i++)
for(int j=0; j<10; j++)
AD[i][j]=0;
}
public void Llenar(int a, int b){
intcont=0;
if(AD[a][b]==0){
AD[a][b]=1;
cont++;
if(cont==40)
System.out.println("***********INICIA CONGRESO**********");
}
}
}
class Acomodador1 implements Runnable
{
Monitor m;
int a;
BuscaA p= new BuscaA();
public Acomodador1(Monitor m)

{
this.m = m;
}
public void run()
{
for(inti=0;i<10;i++)
for(int j=0; j<3;j++)
{
p.Llenar(i,j);
m.Acomodador1("Acomodando
columna "+j);
}
}
}

Congresista

*Asiento:

fila

"+i+"

Congresista

*Asiento:

fila

"+i+"

class Acomodador2 implements Runnable

{
Monitor m;
BuscaA q= new BuscaA();
//String name;
public Acomodador2(Monitor m)
{
this.m = m;
// this.name=name;
}
public void run()
{
for(inti=10;i<20;i++)
for(int j=3; j<6;j++)
{
q.Llenar(i,j);
m.Acomodador2("Acomodando
columna "+j);
}
}
}
class Acomodador3 implements Runnable
{
Monitor m;
BuscaA r= new BuscaA();
public Acomodador3(Monitor m)
{
this.m = m;
}

public void run()

{
for(inti=20; i<30; i++)
for(int j=6; j<9;j++)
{
r.Llenar(i,j);
m.Acomodador3("Acomodando
columna "+j);
}
}
}
public class Principal {
public static void main(String[] args)
{
Monitor m = new Monitor();
Acomodador1 p1= new Acomodador1(m);
Acomodador2 p2= new Acomodador2(m);
Acomodador3 p3= new Acomodador3(m);
AccesoA p4=new AccesoA(m);
AccesoB p5=new AccesoB(m);
Thread a = new Thread(p1);
Thread b = new Thread(p2);
Thread c = new Thread(p3);
Thread d = new Thread(p4);
Thread e = new Thread(p5);
a.start();
b.start();
c.start();
d.start();
e.start();
}
}
CAPTURA DE PANTALLA:

Congresista

*Asiento:

fila

"+i+"

EJERCICIO #3
PLANTEAMIENTO:
En una carpintera se realizan muebles ensamblando 3 partes, existen N1 carpinteros para
realizar la parte1, N2 carpinteros para realizar la parte2, N3 para la parte3; mas N carpinteros
que se encargan de ensamblar las 3 partes del mueble.
Los encargados de ensamblar deben tomar una pieza de cada clase juntar las partes y una vez
ensambladas los carpinteros que le dieron la pieza pueden seguir trabajando (no antes). En la
carpintera solo se armaran 30 muebles y no se podrn producir piezas de ms.
El armado debe hacerse en forma concurrente solo pueden esperarse entre los carpinteros de
un mismo tipo cuando terminan una pieza hasta que los tome un ensamblador (es decir puede
pensar que los ensambladores toman las piezas de a uno). Todos los procesos deben terminar
correctamente, no pueden quedar procesos colgados.
CLASES Y PAQUETES:
Se crean 6 clases, la clase Monitor.java, que es como su nombre lo dice, es el monitor del
programa, por lo cual contiene los 4 procesos sincronizados. Las clases Parte1.java,
Parte2.java, Parte3.java, Ensamblar.java, se crean los hilos implementando la interfaz
Runnable, en cada uno de los hilos creados, mediante su mtodo run, se manda a llamar el
mtodo correspondiente a cada clase. Por ltimo la clase Principal.java, se crea el monitor, y
un hilo para cada clase, se lanzan mediante el mtodo nombre_hilo.start().
CODIGO EN JAVA:
class Monitor
{
private String cad;
private boolean permiso1=true;
private boolean permiso2=true;
private boolean permiso3=true;
public Monitor()
{
cad=null;
}
public synchronized void ArmaParte1 (String cad)
{
while(permiso1==false)
{
try
{
wait();
}catch (Exception e){}
}
System.out.println("Nombre: "+Thread.currentThread().getName()+cad);
permiso1=false;
notify();
}
public synchronized void ArmaParte2 (String cad)

{
while(permiso2==false)
{
try
{
wait();
}catch (Exception e){}
}
System.out.println("Nombre: "+Thread.currentThread().getName()+cad);
permiso2=false;
notify();
}
public synchronized void ArmaParte3 (String cad)
{
while(permiso3==false)
{
try
{
wait();
}catch (Exception e){}
}
System.out.println("Nombre: "+Thread.currentThread().getName()+cad);
permiso3=false;
notify();
}
public synchronized void EnsamblaPieza (String cad)
{
while (permiso1==true)
{
try
{
wait();
}catch (Exception e){}
}
while (permiso2==true)
{
try
{
wait();
}catch (Exception e){}
}
while (permiso3==true)
{
try
{
wait();
}catch (Exception e){}
}

System.out.println("Nombre: "+Thread.currentThread().getName()+cad);
permiso1=true;
permiso2=true;
permiso3=true;
notifyAll();
}
}
class Parte1 implements Runnable
{
Monitor m;
public Parte1(Monitor m)
{
this.m = m;
}
public void run()
{
for(int i=0;i<30;i++)
{
m.ArmaParte1(" Armando pieza 1 ");
}
}
}
class Parte2 implements Runnable
{
Monitor m;
public Parte2(Monitor m)
{
this.m = m;
}
public void run()
{
for(int i=0;i<30;i++)
{
m.ArmaParte2(" Armando pieza 2 ");
}
}
}
class Parte3 implements Runnable
{
Monitor m;

public Parte3(Monitor m)
{
this.m = m;
}
public void run()
{
for(int i=0;i<30;i++)
{
m.ArmaParte3(" Armando pieza 3");
}
}
}
class Ensamblar implements Runnable
{
Monitor m;
public Ensamblar(Monitor m)
{
this.m = m;
}
public void run()
{
for(int i=0;i<30;i++)
{
m.EnsamblaPieza(" Ensamblando mueble"+i);
}
}
}
public class Principal {
public static void main(String[] args)
{
Monitor m = new Monitor();
Parte1 p1= new Parte1(m);
Parte2 p2= new Parte2(m);
Parte3 p3= new Parte3(m);
Ensamblar p4=new Ensamblar(m);
Thread a = new Thread(p1);
Thread b = new Thread(p2);
Thread c = new Thread(p3);
Thread d = new Thread(p4);
a.start();

b.start();
c.start();
d.start();
}}
CAPTURA DE PANTALLA:

EJERCICIO 4
PLANTEAMIENTO:
Supongamos que una carretera por la que circulan coches en los dos sentidos. La carretera
cruza un ro donde solo es posible la circulacin de coches en un sentido. Sobre el puente
pueden estar varios coches del mismo sentido.
CODIGO EN JAVA:
public class CochesOeste extends Thread
{
Puente puente;
publicCochesOeste(Puente p_puente)
{
puente = p_puente;
}
public void run()
{
try
{
puente.entrarCocheOeste(); //tratar de pasar x el puente
System.out.println("ENTRO "+getName());
//PASAR EL PUENTE
sleep(200);
puente.salirCocheOeste();
System.out.println("SALIO "+getName());
}
catch (InterruptedException e)
{
}
}
}
public class CochesEste extends Thread
{ Puentepuente;
publicCochesEste(Puente p_puente)
{
puente = p_puente;
}
public void run()
{
try
{
puente.entrarCocheEste(); //tratar de pasar x el puente
System.out.println("ENTRO "+getName());
//PASAR EL PUENTE
sleep(100);
puente.salirCocheEste();
System.out.println("SALIO "+getName());
}
catch (InterruptedException e)

{
}
}
}
importjava.util.concurrent.locks.*;
public class Puente
{
finalReentrantLockcerrojo = new ReentrantLock();
final Condition okCocheE = cerrojo.newCondition();
final Condition okCocheO = cerrojo.newCondition();
intc,b;
public Puente()
{
b=0;
c=0;
}
public void entrarCocheEste() throws InterruptedException
{
cerrojo.lock();
try
{
while ((b>0)) {
System.out.println("coche del Este esperando..puente ocupado");
okCocheE.await(); //el coche espera
}
c++; //--incrementa el nmero de coches pasando
okCocheE.signal(); //--despierta si hay otro coche esperando
//BAJAR PUENTE
}
finally
{
cerrojo.unlock();
}
}
public void salirCocheEste() throws InterruptedException
{
cerrojo.lock();
try
{
System.out.println("coche del ESTE saliendo..puente libre");
c--; //--disminuye el nro. de coches pasando
if (c==0)
okCocheO.signal(); //--el ltimo coche que pasa
//--comunica al cohe que puede pasar (si
//--hubiera)
}
finally

{
cerrojo.unlock();
}
}
publicvoidentrarCocheOeste() throwsInterruptedException
{
cerrojo.lock();
try
{
while ((c>0)) //--si hay coches pasando
{
System.out.println("Coche del OESTE esperando..puente ocupado");
okCocheO.await(); //--esperar a que pasen los coches
}
b++; //--incrementa el no. de coches pasando
okCocheO.signal(); //--despierta a otro coche si hubiera
//--para que intente pasar
}
finally
{
cerrojo.unlock();
}
}
public void salirCocheOeste() throws InterruptedException
{
cerrojo.lock();
try
{
System.out.println("Coche del OESTE saliendo..puente libre");
b--; //--disminuye el num. decoches pasando
if(b==0)
okCocheE.signal(); //-- el ltimo coche comunica al coche
//--que espera (si hubiera) que puede intentar pasar
}
finally
{
cerrojo.unlock();
}
}
privateint awaited(Condition condicion)
{ //--devuelve el nmero de hilos que esperan sobre la variable condicion
returncerrojo.getWaitQueueLength(condicion);
}
}
public class AppCarrera
{
public static void main(String arg[])
{

booleancarrera=true;
int lap=1;
//--CREAR EL MONITOR
while( carrera==true){
Puente puente = new Puente();
//--CREAR LOS HILOS A LOS QUE SE PASA COMO PARAMETRO EL MONITOR A UTILIZAR
CochesEste c1 = new CochesEste(puente);
CochesOeste b1 = new CochesOeste(puente);
CochesEste c2 = new CochesEste(puente);
CochesOeste b2 = new CochesOeste(puente);
CochesEste c3 = new CochesEste(puente);
CochesOeste b3 = new CochesOeste(puente);
CochesEste c4 = new CochesEste(puente);
CochesOeste b4 = new CochesOeste(puente);
CochesEste c5 = new CochesEste(puente);
CochesOeste b5 = new CochesOeste(puente);
//--PONER NOMBRE A LOS HILOS
//inicia la carrera
c1.setName("CocheE 01\n");
c2.setName("CocheE 02\n");
c3.setName("CocheE 03\n");
c4.setName("CocheE 04\n");
c5.setName("CocheE 05\n");
b1.setName("CocheO 06\n");
b2.setName("CocheO 07\n");
b3.setName("CocheO 08\n");
b4.setName("CocheO 09\n");
b5.setName("CocheO 10\n");
//--EJECUTAR LOS HILOS
try
{
System.out.println(" 'Lap: "+lap+"'");
c1.start();
b1.start();
c2.start();
b2.start();
c3.start();
b3.start();
c4.start();
b4.start();
c5.start();
b5.start();
lap++;
if(lap>=5){

carrera=false;}
Thread.sleep(3000);
}catch (InterruptedException e)
{
}
}
}
}
CAPTURAS DE PANTALLA:

PROBLEMA LECTORES Y ESCRITORES:

PLANTEAMIENTO:
El problema consiste en lo siguiente, Hay una base de datos que es utilizado por varios
procesos, unos leen y otro que escribe. Solo puede utilizar el recurso un proceso y solo uno, es
decir, o bien un proceso estar escribiendo o bien leyendo, pero nunca ocurrir
simultneamente, teniendo en cuenta que si no lo est utilizando nadie, tendr preferencia el
escritor ante el lector.
CLASES Y PAQUETES:
Se cre un paquete llamado Condition Variable el cual contiene las clases que hacen la funcin
de variables de condicin. En cuanto a las clases involucradas directamente con la resolucin
del problema, tenemos la clase ControladorPrefLectores.java, la cual es la clase monitor y
contiene, por tanto, los mtodos sincronizados, tanto la clase Lector.java como la clase
Escritor.java, son las clases hilo, en las cuales se utiliza la interfaz Runnable. La clase
BaseDatos.java, contiene mtodos que controlan la impresin de los letreros de los lectores y
escritores. La clase MonLectoresEscritores.java contiene el main, en el cual se crean 5 hilos del
tipo lector y 5 del tipo escritor.
CODIGO EN JAVA:
public class ControladorPrefLectores {
int contadorLectores = 0;
boolean hayEscritor = false;
CV2 okToWrite = new CV2("okToWrite");
CV2 okToRead = new CV2("okToRead");
public ControladorPrefLectores () { }
public synchronized void empezarLectura (int i)
{ while (hayEscritor)
{ System.out.println ("el lector "+i+" se queda bloqueado en el monitor");
okToRead.DELAY(this);
}
contadorLectores++;
okToRead.RESUME(this);
}
public synchronized void terminarLectura (int i)
{
contadorLectores --;
if (contadorLectores == 0)
okToWrite.RESUME(this);
}
public synchronized void empezarEscritura (int i)
{ while (hayEscritor || (contadorLectores != 0))

{ System.out.println ("el escritor "+ i +" se queda bloqueado en el monitor");

okToWrite.DELAY(this);
}
hayEscritor = true;
}
public synchronized void terminarEscritura (int i)
{ hayEscritor = false;
if (!okToRead.EMPTY(this))
okToRead.RESUME(this); //damos preferencia a lectores
else
okToWrite.RESUME(this);
}
}
public class Lector implements Runnable {
private int i;
BaseDatos bd;
ControladorPrefLectores controlador;
public Lector (BaseDatos _bd, ControladorPrefLectores _controlador, int _i)
{ i=_i;
bd = _bd;
controlador = _controlador;
}
public void run ()
{ for (int j=0;j<3;j++)
{ System.out.println ("Lector "+i+" quiere leer");
controlador.empezarLectura(i);
bd.leer (i);
controlador.terminarLectura(i);
System.out.println ("Lector "+i+" usa su dato");
}
}
}
import java.util.*;
public class Escritor implements Runnable {
private int i;
BaseDatos bd;
ControladorPrefLectores controlador;
public Escritor (BaseDatos _bd, ControladorPrefLectores _controlador, int _i)
{ i =_i;
bd = _bd;
controlador = _controlador;
}
public void run ()
{ for (int j=0;j<3;j++)

{ System.out.println ("Escritor "+i+" quiere escribir");

controlador.empezarEscritura(i);
bd.escribir (i,i);
controlador.terminarEscritura(i);
System.out.println ("Escritor "+i+" usa su dato");
}
}
}
public class BaseDatos
{ private int valor = 0;
public BaseDatos (int v)
{ valor = v; }
public int leer (int i)
{ System.out.println ("Lector "+i+" leyendo");
try {Thread.sleep (500);}
catch (Exception e) {}
System.out.println ("Lector "+i+" leyendo");
System.out.println ("Lector "+i+" leyendo");
return valor;
}
public void escribir (int v, int i)
{ System.out.println ("Escritor "+i+" escribiendo");
System.out.println ("Escritor "+i+" escribiendo");
System.out.println ("Escritor "+i+" escribiendo");
valor = v;
}
}
public class MonLectoresEscritores
{ static BaseDatos bd = new BaseDatos(0);
static ControladorPrefLectores controlador = new ControladorPrefLectores ();
public static void main (String args[])
{ for (int i=0;i<5;i++)
new Thread (new Lector (bd, controlador, i)).start();
for (int i=0;i<5;i++)
new Thread (new Escritor (bd, controlador, i)).start();
}
}

CAPTURA DE PANTALLA:

PROBLEMA ASIGNA NOTA

PLANTEAMIENTO:
El problema consiste en realizar un simulador, entre un maestro y un alumno, el maestro le
asignar una calificacin al alumno y este esperar dicha accin para poder consultar su nota.
CLASES Y PAQUETES:
Se elaboraron 4 clases, la clase Monitor.java, contiene los mtodos sincronizados, las clases
Docente.java y Alumno.java son las clases hilo, creadas mediante la herencia de la clase
Thread. La clase Principal.java, contiene el mtodo main en el que se lee desde teclado la
calificacin asignada por el docente, y se le pasa como argumento al hilo de tipo Docente y al
hilo de tipo Alumno.
CODIGO EN JAVA:
class Monitor
{
private float calificacion;
private boolean disponible = true;//false;
public synchronized float consulta_calif() {
while (disponible == true) {//==false
try {
wait();
} catch (InterruptedException e) {
}
}
disponible = true; //false;
notify();
return calificacion;

}
public synchronized void asigna_calif(float valor) {
while (disponible == false) {//true
try {
wait();
} catch (InterruptedException e) {
}
}
calificacion = valor;
disponible = false; //true;
notify();
}
}
class Docente extends Thread {
private Monitor monitor1;
private int num;
private float calif;
public Docente(Monitor m, float n)
{
monitor1 = m;
calif=n;
}
public void run() {
//for(int i=0;i<5;i++)
monitor1.asigna_calif(calif);
System.out.println("Docente #"+this.num+" pone: " +calif);
try {
sleep((int)(Math.random() * 100));
} catch (InterruptedException e) {
}
}
}
class Alumno extends Thread {
private Monitor monitor1 ;
private int num;
public Alumno(Monitor m)
{
monitor1 = m;
}
public void run() {
float valor = 0;
//for (int i = 0; i < 5; i++)
{

valor = monitor1.consulta_calif();
System.out.println("Alumno #"+this.num+" obtiene: "+valor );
}
}
}
import java.util.Scanner;
import java.io.*;
public class Principal
{
public static void main(String args[])
{
Scanner lector= new Scanner(System.in);
Monitor m= new Monitor();
int i=0;
do{
try
{
System.in.read();
}
catch(java.io.IOException e) {}
System.out.println("Introduzca calificacin:");
float cal=lector.nextFloat();
Docente hilo1 =new Docente(m,cal);
Alumno hilo2= new Alumno(m);
hilo1.start();
hilo2.start();
}while(i<10);
}
}

CAPTURA DE PANTALLA:

PROBLEMA DE LOS FILOSOFOS

PLANTEAMIENTO:
Cinco filsofos se sientan alrededor de una mesa y pasan su vida cenando y pensando. Cada
filsofo tiene un plato de fideos y un tenedor a la izquierda de su plato. Para comer los fideos
son necesarios dos tenedores y cada filsofo slo puede tomar los que estn a su izquierda y
derecha. Si cualquier filsofo toma un tenedor y el otro est ocupado, se quedar esperando,
con el tenedor en la mano, hasta que pueda tomar el otro tenedor, para luego empezar a
comer.
Si dos filsofos adyacentes intentan tomar el mismo tenedor a una vez, se produce
una condicin de carrera: ambos compiten por tomar el mismo tenedor, y uno de ellos se
queda sin comer.
Si todos los filsofos toman el tenedor que est a su derecha al mismo tiempo, entonces todos
se quedarn esperando eternamente, porque alguien debe liberar el tenedor que les falta.
Nadie lo har porque todos se encuentran en la misma situacin (esperando que alguno deje
sus tenedores).
CODIGO EN JAVA:
//clase semforo
classSemaforo
{
privateint contador;
publicSemaforo (int inicial)
{
contador= inicial;
}
publicSemaforo ()
{
contador= 0;
}
publicsynchronizedvoid subir()
{
contador++;
notifyAll();
}
publicsynchronizedvoid bajar()
{
try
{

while(contador == 0)
wait();
}
catch (InterruptedException e){};
contador--;
}
}
//clase Mesa
class Mesa
{
private Tenedor tenedores[];
privateint comensales;
public Mesa (int comensales)
{
this.comensales= comensales;
tenedores= new Tenedor[comensales];
for (int i= 0; i < comensales; i++)
tenedores[i]= new Tenedor(i);
}
public Tenedor tenedor(int i)
{
return tenedores[i];
}
publicintmi_tenedor_derecho(int i)
{
return (i+1)%comensales;
}
publicintmi_tenedor_izquierdo(int i)
{
return i;
}
}
//clase Tenedor
class Tenedor
{
privateint identidad;
privateboolean cogido;

public Tenedor (int identidad)

{
this.identidad= identidad;
}
synchronizedpublicvoid coger()
{
if (cogido)
{
System.out.println (" -Tenedor " + identidad + ": SE ESTAN PELEANDO POR MI!");
System.exit(1);
}
else
{
cogido= true;
System.out.println (" -Tenedor " + identidad + " ha sido tomado");
}
}
synchronizedpublicvoid soltar()
{
cogido= false;
System.out.println (" -Tenedor " + identidad + " ha sido soltado");
}
}
//clase Filosofo
class Filosofo implementsRunnable
{
privateThread t;
protected Mesa mesa;
protectedintind_izq, ind_der;
protectedint identidad;
public Filosofo (int identidad, Mesa mesa)
{
this.identidad= identidad;
this.mesa= mesa;
ind_izq= mesa.mi_tenedor_izquierdo(identidad);
ind_der= mesa.mi_tenedor_derecho(identidad);
t= new Thread(this);

t.start();
}

protectedvoid pensar()
{
try
{
System.out.println ("Filosofo " + identidad + " esta pensando");
intdelay= (int)(Math.random()*1000);
t.sleep(delay);
System.out.println ("Filosofo " + identidad + " ha dejado de pensar");
} catch (InterruptedException e) {}
}
protectedvoid comer()
{
try
{
System.out.println ("Filosofo " + identidad + " esta comiendo");
intdelay= (int)(Math.random()*1000);
t.sleep(delay);
System.out.println ("Filosofo " + identidad + " ha terminado de comer");
} catch (InterruptedException e) {}
}
protectedvoidprotocolo_entrada()
{
System.out.println ("Protocolo antiguo");
Tenedor tizq= mesa.tenedor(ind_izq);
Tenedor tder= mesa.tenedor(ind_der);
tizq.coger();
tder.coger();
}
protectedvoidprotocolo_salida()
{
Tenedor tizq= mesa.tenedor(ind_izq);
Tenedor tder= mesa.tenedor(ind_der);
tizq.soltar();
tder.soltar();
}

publicvoidrun()
{
while (true)
{
pensar();
protocolo_entrada();
comer();
protocolo_salida();
}
}
}
// Principal
class principal
{
publicstaticvoidmain (Stringargs[])
{
int comensales=5;
System.out.println ("Poniendo la mesa para " + comensales + " comensales");
Mesa mesa= new Mesa(comensales);
System.out.println ("Creando a los filosofos y sentandolos a la mesa");
for (int i= 0; i<comensales; i++)
{
Filosofo f= new Filosofo(i, mesa);
}
}
}
CAPTURAS DE PANTALLA:

PROBLEMA FACTURA ELECTRNICA

PLANTEAMIENTO:
Es una simulacin en la cual un cliente realiza una compra, el empleado le pide que espere su
nota, el cliente la espera, posteriormente se le hace entrega de la misma para que el cliente
pueda realizar el pago, mientras esto ocurre el empleado espera, por ltimo el cliente recibe
su factura y realiza su pago.
CODIGO EN JAVA:
import java.io.*;
public class principalCV {
public static void main ( String args[] )
{
try {
monitor f = new monitor(1234);
cliente bety = new cliente ("Bety", f);
vendedor marco = new vendedor ( "Marco", f);
bety.start();
marco.start();
bety.join();
marco.join();
}
catch ( Exception e ){
System.out.println ( e.toString() );
}
}
}

public class vendedor extends Thread {

monitor factura;
String nombre;
public vendedor(String nombre, monitor factura) {
this.nombre=nombre;
this.factura=factura;
}
public void run(){
try{
System.out.println(nombre + " dice: En que le puedo servir ");
factura.atiende();
Thread.sleep(3000);
System.out.println(nombre + " dice: Espere en lo que le generamos su nota");
factura.hacenota();
Thread.sleep(3000);
System.out.println(nombre + " dice: Aqui esta su nota, vaya a pagar");
factura.danota();
Thread.sleep(3000);
System.out.println(nombre + " espera al cliente a que pague");
factura.esperaven();
Thread.sleep(3000);
// System.out.println(nombre + " dice: ");
factura.dafactura();
}
catch(InterruptedException e){
}
}
}
public class cliente extends Thread {
monitor factura;
String nombre;
public cliente(String nombre, monitor factura) {
this.nombre=nombre;
this.factura=factura;
}
public void run(){
try{
factura.espera_atencion();
System.out.println(nombre + " dice: Me gustaria comprar X mercancia ");
Thread.sleep(3000);
factura.esperanota();
System.out.println(nombre + " dice: Esperare mi nota");
Thread.sleep(3000);
factura.paga();

System.out.println(nombre + " dice: OK");

Thread.sleep(3000);
factura.pagaclie();
System.out.println(nombre + " esta pagando");
Thread.sleep(3000);
factura.pagoclie();
System.out.println(nombre + " dice: Ya he pagado mi nota");
}
catch(InterruptedException e){
}
}
}
public class monitor {
private int numfac;
boolean permiso= false;
boolean permiso1=false;
boolean permiso2=false;
boolean permiso3=false;
boolean permiso4=false;
public monitor(int numfac) {
this.numfac=numfac;
}
//////////////////////////////////////Para ver kien atiende
synchronized void espera_atencion(){
if(!permiso)
try{
wait();
}
catch(InterruptedException e){
}
permiso=false;
notify();
}
synchronized void atiende(){
if(permiso)
try{
wait();
}
catch(InterruptedException e){
}
permiso=true;
notify();
}
/////////////////////////////////////////en lo ke va a pagar
synchronized void hacenota(){
if(permiso1)
try{
wait();

}
catch(InterruptedException e){
}
permiso1=true;
notify();
}
synchronized void esperanota(){
if(!permiso1)
try{
wait();
}
catch(InterruptedException e){
}
permiso1=false;
notify();
}
///////////////////////////////////////ve a pagar
synchronized void danota(){
if(permiso2)
try{
wait();
}
catch(InterruptedException e){
}
permiso2=true;
notify();
}
synchronized void paga(){
if(!permiso2)
try{
wait();
}
catch(InterruptedException e){
}
permiso2=false;
notify();
}
//////////////////////////////////////////////
synchronized void pagaclie(){
if(permiso3)
try{
wait();
}
catch(InterruptedException e){
}
permiso3=true;
notify();

}
synchronized void esperaven(){
if(!permiso3)
try{
wait();
}
catch(InterruptedException e){
}
permiso3=false;
notify();
}
//////////////////////////////////
synchronized void dafactura(){
if(!permiso4)
try{
wait();
}
catch(InterruptedException e){
}
System.out.println("Recibe factura con numero "+numfac);
permiso4=false;
notify();
}
synchronized void pagoclie(){
if(permiso4)
try{
wait();
}
catch(InterruptedException e){
}
permiso4=true;
notify();
}
}

CAPTURA DE PANTALLA:

PROBLEMA DE MISIONEROS Y CANIBALES

PLANTEAMIENTO:
En una olla el cocinero tiene a determinado numero de misioneros, los canbales se comen
uno por uno, cuando han terminado con los misioneros que estaban en la olla, avisan al
cocinero para que este prepare ms misioneros, los canbales debern esperar a que el
cocinero termine de preparar la olla para que puedan volver a comer.
CODIGO EN JAVA:
package misioneros;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Cocinero extends Thread {
public Olla olla;
boolean ctrl;
public Cocinero (Olla olla) {
this.olla = olla;
ctrl = true;
}
@Override

public void run () {

while (ctrl) {
olla.cocinar();
try { sleep(30); } catch (InterruptedException ex) { }
}
}
}
package misioneros;
public class Loco extends Thread {
private Olla olla;
boolean ctrl;
public Loco (Olla olla) {
this.olla = olla;
ctrl = true;
}
@Override
public void run () {
while (ctrl) {
olla.devorado();
try { sleep(30); } catch (InterruptedException ex) { }
}
}
}
package misioneros;
class Misioneros {
public static void main(String[] args) {
Olla ecko = new Olla(5);
Cocinero chef = new Cocinero(ecko);
Loco l = new Loco(ecko);
chef.start();
l.start();
}
}
package misioneros;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Olla {

private int misioneros;
private boolean lleno;
public Olla (int x) {
misioneros = x;
lleno = true;
}
public synchronized boolean cocinar () {
while (lleno==false) {
System.out.println("Cocinando a un canibal, ...");
misioneros++;
if (misioneros ==5){
System.out.println("ytytyytytyt");
lleno=true;}
else{
//misioneros++;
lleno=false;
System.out.println("sjhjhf");
}
notify();
}
try { wait(); } catch (InterruptedException ex) { }

// Espero a que lo coman

System.out.println("//Sigo durmiendo...");
if (misioneros == 5) {
notify();
return true;
}
else {
notify();
return false;
}
}

public synchronized boolean devorado () {

while (misioneros==0) {
// Mientras no haya misioneros listos
System.out.println("Quiero comer, me espero");

lleno=false;
//notify();
// Le digo al cocinero que saque uno de la olla
try { wait(); } catch (InterruptedException ex) { } // Espero a que lo saque
}
System.out.println("Me comere uno...");
System.out.println("ME COMi A UN MISIONERO!!!!");
misioneros--;
// Esperara al siguiente listo
notify();
// Notifico que ya comif (misioneros == 0) {
return false;
}
else return true;
}
}
CAPTURA DE PANTALLA:

DIAPOSITIVAS
PROGRAMA 1: PRODUCTOR CONSUMIDOR
El productor genera un entero entre 0 y 9, lo almacena en un objeto Monitor_Almacen,
e imprime el nmero generado, el productor duerme durante un tiempo aleatorio entre
0 y 100 milisegundos antes de repetir el ciclo de generacin de nmeros.
El consumidor, por su parte, est hambriento, consume todos los enteros de
Monitor_Almacen (exactamente el mismo objeto en que el productor puso los enteros
tan pronto como estn disponibles.

PROGRAMA 2: EL PROBLEMA PRODUCTOR/CONSUMIDOR2 CON JAVA.

Se compone de cuatro clases simples:
Cola_Monitor,cuyo acceso se trata de sincronizar a sus mtodos, es el monitor.
Productor, es un hilo que genera datos para la cola
Consumidor, es un hilo que consume datos de la cola.
ProCon, crea una Cola_Monitor, Productor y Consumidor, donde el objeto
monitor sincroniza a los procesos y permite la exclusin mutua.

PROGRAMA3: EL PROBLEMA DE LOS JARDINES

Existen en N hilos que compiten por entrar por una puerta para incrementar un valor.

PROGRAMA4: PRODUCTOR CONSUMIDOR CON CONDICIONES DE

BLOQUEO
En Java podemos pensar que hay una condicin(declarada de manera implcita) por cada
objeto sincronizado. Por lo cual debemos declarar los recursos compartidos como
objetos que tendrn asociado una variable de condicin para verificar su estado.
Las variables tipos Condition

que solo pueden declararse dentro de un monitor,

proporciona a los monitores la capacidad de sincronizacin.

PROGRAMA5: PRODUCTOR CONSUMIDOR_CARPETA