Este documento presenta 4 programas desarrollados con monitores en Java para ilustrar conceptos de programación concurrente y paralela. El primer programa simula retiros y depósitos en un cajero automático usando monitores. El segundo programa es similar pero usa semáforos en lugar de monitores. El tercer programa ilustra el uso de un monitor para incrementar y decrementar un valor de forma sincronizada. El cuarto programa incrementa un contador de 1 a 10 de forma sincronizada usando 2 hilos y un monitor.

1. BENEMERITA UNIVERSIDAD
AUTONOMA DE PUEBLA
FACULTAD DE CIENCIAS
DE LA COMPUTACION
PROGRAMACION CONCURRENTE Y PARALELA
PROGRAMAS DE MONITORES

2. LEZAMA SANCHEZ ANA LAURA
H
Introducción:
En esta práctica se realizaron 4 programas con monitores
Desarrollo:
El primer programa es el mismo que el de la práctica 4, donde se simula el retiro y deposito de
dinero.
public class cliente1 implements Runnable
{
private Monitor_Cajero caja1;
public cliente1(Monitor_Cajero A)
{
this.caja1=A;
}
public void run()
{

3. int cantidad;
for (int i=0; i<5; i++)
{
do
{
cantidad=((int)(Math.random()*1000));
}
while (cantidad<1 || cantidad>1000);
System.out.println ("Retirando: "+cantidad);
caja1.retira(cantidad);
}
}
}
public class cliente2 extends Thread
{
private Monitor_Cajero caja1;
public cliente2(Monitor_Cajero A)
{
this.caja1=A;
}
public void run()
{
int cantidad;

4. for (int i=0; i<5; i++)
{
do
{
cantidad=((int)(Math.random()*1000));
}
while (cantidad<1 || cantidad>1000);
System.out.println ("Ingresando: "+cantidad);
caja1.ingresar(cantidad);
}
}
}
public class Monitor_Cajero
{
private int cantidad;
public Monitor_Cajero()
{
cantidad=10000;
}
public synchronized void retira(int x)
{
while (cantidad-x <=0)
try {wait();}

5. catch (InterruptedException e)
{
System.err.println ("Error"+e.toString());
}
cantidad=cantidad-x;
notify();
}
public synchronized void ingresar(int x)
{
while (cantidad+x>=10000)
try {wait();}
catch (InterruptedException e){System.err.println ("Error"+e.toString());}
cantidad=cantidad+x;
notify();
}
}
//clase principal
import java.io.*;
public class cajeroautomatico
{
public static void main (String []args)
{
Monitor_Cajero A=new Monitor_Cajero();

6. cliente1 cli1=new cliente1(A);
cliente2 cli2=new cliente2(A);
Thread hilo1=new Thread(cli1);
Thread hilo2=new Thread(cli2);
hilo1.start();
hilo2.start();
}
}
SALIDA
********************************************************************************
El segundo programa es el mismo que el de la practica 4 pero solo este se presenta con semáforos
y su ejecución es la misma.
public class SemaforoBinario {
protected int contador = 0;
public SemaforoBinario (int valorInicial) {
contador = valorInicial;
}

7. synchronized public void WAIT () {
while (contador == 0)
try {
wait();
}
catch (Exception e) {}
contador--;
}
synchronized public void SIGNAL () {
contador = 1;
notify();
}
}
class Semaphore
{
private int count;
public Semaphore(int n)
{
this.count = n;
}
public synchronized void WAIT()
{
while(count == 0)
{

8. try
{
wait();
}
catch (InterruptedException e) {//keep trying}
}
count--;
}
}
public synchronized void SIGNAL()
{
count++;
notify();
}
}
public class cajero
{
private int cantidad;
public cajero() {cantidad=10000;}
public synchronized void retira(int x)
{
while (cantidad-x <=0)
try {wait();}
catch (InterruptedException e)
{

9. System.err.println ("Error"+e.toString());
}
cantidad=cantidad-x;
notify();
}
public synchronized void ingresar(int x)
{
while (cantidad+x>=10000)
try {wait();}
catch (InterruptedException e){System.err.println ("Error"+e.toString());}
cantidad=cantidad+x;
notify();
}
}
import java.io.*;
class Procesos1
{
protected static final SemaforoBinario SA = new SemaforoBinario(0);
protected static final SemaforoBinario SB = new SemaforoBinario(0);
protected static final SemaforoBinario SC = new SemaforoBinario(0);
protected static final SemaforoBinario SD = new SemaforoBinario(0);
protected static final SemaforoBinario SE = new SemaforoBinario(0);
protected static final SemaforoBinario mutex = new SemaforoBinario(1);

10. public static void main(String args[]) throws IOException
{
try
{
cajero caja=new cajero();
Thread cli1 = new Thread(new cliente1(caja));
Thread cli2 = new Thread(new cliente2(caja));
cli1.start();
cli2.start();
Thread.sleep(300);
}
catch (InterruptedException e) {}
// System.out.println(" Termine...");
// System.exit(0);
}
}
class cliente1 extends Procesos1 implements Runnable
{
private cajero caja1;
public cliente1(cajero x)
{
this.caja1=x;

11. }
public void run()
{
try
{
mutex.WAIT();
int cantidad;
for (int i=0; i<5; i++)
{
do
{
cantidad=((int)(Math.random()*1000));
}
while (cantidad<1 || cantidad>1000);
System.out.println ("Retirando: "+cantidad);
caja1.retira(cantidad);
}
Thread.sleep(500);
mutex.SIGNAL();
SA.SIGNAL();
}
catch (InterruptedException e) {}
}
}

12. public class cliente2 extends Procesos1 implements Runnable
{
private cajero caja1;
public cliente2(cajero x)
{
this.caja1=x;
}
public void run()
{
try
{
mutex.WAIT();
int cantidad;
for (int i=0; i<5; i++)
{
do
{
cantidad=((int)(Math.random()*1000));
}
while (cantidad<1 || cantidad>1000);
System.out.println ("Ingresando: "+cantidad);
caja1.ingresar(cantidad);
}
Thread.sleep(500);

13. mutex.SIGNAL();
SB.SIGNAL();
}
catch (InterruptedException e) {}
}
}
public class cliente3 extends Procesos1 implements Runnable
{
private cajero caja1;
public cliente3 (cajero x)
{
this.caja1=x;
}
public void run()
{
try
{
mutex.WAIT();
int cantidad;
for (int i=0; i<5; i++)
{
do

14. {
cantidad=((int)(Math.random()*1000));
}
while (cantidad<1 || cantidad>1000);
System.out.println ("Ingresando: "+cantidad);
caja1.ingresar(cantidad);
}
Thread.sleep(500);
mutex.SIGNAL();
SB.SIGNAL();
}
catch (InterruptedException e) {}
}
}
//clase principal
import java.io.*;
public class cajeroautomatico
{
public static void main (String []args)
{
cajero caja=new cajero();
cliente1 c1=new cliente1(caja);
cliente2 c2=new cliente2(caja);
cliente3 c3=new cliente3(caja);
c1.start();

15. c2.start();
c3.start();
}
}
Salida
********************************************************************************
El tercer programa es el monitor ejemplo donde desde el cuerpo del código sele asigno una
cantidad de 100 y de acuerdo a las instrucciones se incrementa o decrementa.
public class proceso1 implements Runnable
{
Monitor_Ejemplo A;
int i;
public proceso1(Monitor_Ejemplo A)
{
this.A=A;
this.i=100;
}
public void run()
{

16. A.dec(i);
A.inc(i);
A.valor();
}
}
public class proceso2 implements Runnable
{
Monitor_Ejemplo A;
int i;
public proceso2(Monitor_Ejemplo A)
{
this.A=A;
this.i=20;
}
public void run()
{
A.dec(i);
A.inc(i);
A.valor();
}
}

17. public class Monitor_Ejemplo
{
private int dato;
public Monitor_Ejemplo()
{
dato=10;
}
public synchronized void dec(int cant)
{
dato=dato-cant;
System.out.println(dato);
}
public synchronized void inc(int cant)
{
dato=dato+cant;
System.out.println(dato);
}
public synchronized int valor()
{
System.out.println(dato);
return dato;
}

18. }
public class Principal
{
public static void main(String args[])
{
Monitor_Ejemplo A=new Monitor_Ejemplo();
proceso1 pro1=new proceso1(A);
proceso2 pro2=new proceso2(A);
Thread hilo1=new Thread(pro1);
Thread hilo2=new Thread(pro2);
hilo1.start();
hilo2.start();
}
SALIDA

19. ********************************************************************************
El cuarto programa es el monitor incremento donde el único método es el imprimir del al 10, con
2 hilos imprimiendo cada hilo 5 números de forma sincronizada.
public class proceso1 implements Runnable
{
Monitor_Incremento A;
int i;
public proceso1(Monitor_Incremento A)
{
this.A=A;
}
public void run()
{
for(int i=1;i<=5;i++)
{
A.sumaUno();
}
}
}
public class proceso2 implements Runnable
{
Monitor_Incremento A;
int i;
public proceso2(Monitor_Incremento A)

20. {
this.A=A;
}
public void run()
{
for(int i=1;i<=5;i++)
{
A.sumaUno();
}
}
}
public class Monitor_Incremento
{
private int x;
public Monitor_Incremento()
{
x=0;
}
public synchronized void sumaUno()
{
x=x+1;
System.out.println(x);
}

21. }
public class PruebaMonitor
{
public static void main(String[]args)
{
Monitor_Incremento A=new Monitor_Incremento();
proceso1 pro1=new proceso1(A);
proceso2 pro2=new proceso2(A);
Thread hilo1=new Thread(pro1);
Thread hilo2=new Thread(pro2);
hilo1.start();
hilo2.start();
}
}
SALIDA
*******************************************************************************
Conclusión:

22. En la elaboración de estos programas se asimilo de mejor forma el concepto de monitor
Bibliografia
http://www.cs.buap.mx/~mceron/principal_con.html