Вы находитесь на странице: 1из 14

REPORTE CON SINCRONIZACION

Antropfagos (Canbales)
Objetivo: Implementar el problema de los antropfagos (Canbales) usando la sincronizacin,
dando una salida satisfactoria.
Cdigo:
public class cocinero extends Thread{
private olla o;
public cocinero (olla ol){this.o=ol;}
public void run(){
for (int i=0; i<40; i++)
o.llenar(i);
try{sleep((int)Math.random()*3000);}
catch(InterruptedException e){
System.out.println("Error"+e.toString());}
}
}
public class salvaje extends Thread{
private olla o;
public salvaje(olla ol){this.o=ol;}
public void run(){
for (int i=0; i<40; i++)
o.comer(i);
try{sleep((int)Math.random()*3000);}
catch(InterruptedException e){
System.out.println("Error"+e.toString());}
}
}
import java.io.*;
class Misionero{
public static void main (String []args){
olla oll=new olla();
cocinero c=new cocinero(oll);
salvaje s=new salvaje(oll);
c.start();
s.start();
}
}
public class olla{
private boolean vacio=true;
private int misioneros=10;
public synchronized void llenar(int g){
while (!vacio)
{
try{wait();}
catch (InterruptedException e){System.err.println
("Exception"+e.toString());}

}
misioneros=g;
System.out.println("Cocinando misionero"+g);
misioneros=g; //si no esta lleno agreg misioneros
misioneros=misioneros+1;
vacio=false;
notify();
}
public synchronized void comer(int i){
while (misioneros==0)
{
vacio=true;
notify();
try{wait();}
catch (InterruptedException e){System.err.println
("Exception"+e.toString());}
}
if (misioneros!=0){
System.out.println("comiendo misionero"+i);
misioneros=misioneros-1;}
else
System.out.println("olla vacia");
}
}
import java.io.*;
class Comida{
public static void main (String []args){
olla olla1=new olla();
cocinero c=new cocinero(olla1);
salvaje s=new salvaje(olla1);
c.start();
s.start();
}
}
Corrida:

Conclusin:
En la programacin concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semforos, monitores, sincronizacin, etc. En este caso usamos
mtodos sincronizados para nuestro fin.
Filsofos
Objetivo: Implementar el problema de los filsofos usando la
sincronizacin, dando una salida satisfactoria
Cdigo:
class Filosofos extends Thread
{
int quiensoy=0;
SemaforoGeneral tender, tenizq, cont;
int numero=10;
public Filosofos(int quiensoy1, SemaforoGeneral cont1, SemaforoGeneral tender1,
SemaforoGeneral tenizq1)
{
quiensoy=quiensoy1;
tender=tender1;
cont=cont1;
System.out.println(Integer.toString(quiensoy));
}
public void run(){
for(int j=0; j<numero; j++)
{
System.out.println("Filosofo" + quiensoy + "pensando");
cont.WAIT();
tender.WAIT();
tenizq.WAIT();
System.out.println("Filosofo" + quiensoy + "comiendo");
try{
Thread.sleep(500);
}
catch (Exception e){}
System.out.println("Filosofo" + quiensoy + "termina de
comer");
tender.SIGNAL();
tenizq.SIGNAL();
cont.SIGNAL();
}
}
}
public class SemaforoGeneral extends SemaforoBinario
{
public SemaforoGeneral(int valorinicial)
{

super(valorinicial);
}
synchronized public void SIGNAL()
{
contador++;
notify();
}
}
class FilosofosPrueba
{
Filosofos Filosofos[]=new Filosofos[25];
SemaforoGeneral tenedores[]=new SemaforoGeneral[5];
SemaforoGeneral contador=new SemaforoGeneral(4);
int numfilosofos=5;
public FilosofosPrueba()
{
for (int i=0; i<numfilosofos;i++)
{
tenedores[i]=new SemaforoGeneral(i);
}
for(int i=0;i<numfilosofos;i++)
{
Filosofos[i]=new
Filosofos(i,contador,tenedores[i],tenedores[(i+1)%numfilosofos]);
}
}
public static void main(String a[])
{
System.out.println("Filosofo pensando");
new FilosofosPrueba();
}
}
public class SemaforoBinario
{
protected int contador=0,valorinicial=0;
public SemaforoBinario(int valorinicial)
{
contador=valorinicial;}
synchronized public void WAIT()
{
while (contador==0)
try
{
wait();
}
catch(Exception e){}
contador--;
}

synchronized public void SIGNAL()


{
contador=1;
notify();
}
}
Corrida:

Conclusin:
En la programacin concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semforos, monitores, sincronizacin, etc. En este caso usamos
mtodos sincronizados para nuestro fin.
Lectores y escritores
Objetivo: Implementar el problema de lectores y escritores usando la sincronizacin, dando una
salida satisfactoria
Cdigo:
class semaforo{
final static int vacio=0;
final static int leyendo=0;
final static int escribiendo=0;
protected int estado=vacio;
protected int num_lectores=0;
public synchronized void leer(){
if(estado==vacio)
estado=leyendo;
else
if(estado!=leyendo)

while(estado==leyendo){
try{
wait();
}
catch(InterruptedException e){
System.out.println("Excepcion: "+e.toString());
}
estado=leyendo;
num_lectores++;
}
}
public synchronized void escribir(){
if(estado==vacio)
estado=escribiendo;
else
while(estado!=escribiendo){
try{
wait();
}
catch(InterruptedException e){
System.out.println("Excepcion: "+e.toString());
}
}
}
public synchronized void desblo_escritores(){
estado=vacio;
notify();
}
public synchronized void desblo_lectores(){
num_lectores--;
if(num_lectores==0){
estado=vacio;
notify();
}
}
}
class TLector extends Thread{
semaforo sem;
TLector(String nombre, semaforo s){
super(nombre);
this.sem=s;
}
public void run(){
System.out.println(getName()+" Intentando leer libro");
sem.leer();
System.out.println(getName()+" Ya ha leido libro");
try{
sleep(((int)Math.random())*5000);

}
catch(InterruptedException e){
System.out.println("Excepcion :" +e.toString());
}
sem.desblo_lectores();
}
}
class TEscritor extends Thread{
semaforo sem;
TEscritor(String nombre, semaforo s){
super(nombre);
this.sem=s;
}
public void run(){
System.out.println(getName()+" Intentando escribir libro");
sem.escribir();
System.out.println(getName()+" Ya ha escrito libro");
try{
sleep(((int)Math.random())*5000);
}
catch(InterruptedException e){
System.out.println("Excepcion :" +e.toString());
}
sem.desblo_escritores();
}
}
class Lesc_sinc{
public static void main(String args[]){
semaforo sem=new semaforo();
for(int j=1; j<11; j++)
new TEscritor("Escritor"+j,sem).start();
for(int i=1; i<11; i++)
new TLector("Lector"+i,sem).start();
}
}
Corrida:

Conclusin:
En la programacin concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semforos, monitores, sincronizacin, etc. En este caso usamos
mtodos sincronizados para nuestro fin.
Rebotador
La entidad bsica a la que el sistema operativo asigna tiempo de CPU. Un subproceso puede
ejecutar cualquier parte del cdigo de una aplicacin, incluso una parte que otro subproceso est
ejecutando. Todos los subprocesos de un proceso comparten el espacio de direcciones virtual,
variables globales y recursos de sistema operativo del proceso.
El siguiente programa hace que una pelota rebote alrededor de un rectngulo en la pantalla.
Problema:
El problema con este programa es que, mientras la pelota se encuentra rebotando, nada mas puede
ocurrir.
Cdigo:
import java.awt.*;
import java.applet.Applet;
import java.awt.event.*;
public class Rebotador extends Applet implements ActionListener
{
private Button iniciar;
public void init()
{
iniciar=new Button("Iniciar");
add(iniciar);
iniciar.addActionListener(this);
}
public void actionPerformed(ActionEvent event)

{
if(event.getSource() == iniciar)
{
Graphics g= getGraphics();
Pelota pelota = new Pelota(g);
pelota.mostrar();
}
}
}
class Pelota
{
private Graphics g;
private int x = 7, xCambio = 7;
private int y = 0, yCambio = 2;
private int diametro = 10;
private int rectIzqX = 0, rectDerX = 100;
private int rectSupY = 0, rectInfY = 100;
public Pelota(Graphics graficos)
{ g = graficos; }
public void mostrar()
{
g.drawRect(rectIzqX, rectSupY, rectDerX - rectIzqX+10, rectInfY - rectSupY+10);
for(int n = 1; n < 1000; n++)
{
g.setColor(Color.white);
g.fillOval(x, y, diametro, diametro);
if(x + xCambio <= rectIzqX)
xCambio = -xCambio;
if(x + xCambio >= rectDerX)
xCambio = -xCambio;
if(y + yCambio <= rectSupY)
yCambio = -yCambio;
if(y + yCambio >= rectInfY)
yCambio = -yCambio;
x = x + xCambio;
y = y + yCambio;
g.setColor(Color.red);
g.fillOval(x, y, diametro, diametro);
try{
Thread.sleep (50);
}
catch (InterruptedException e){
System.err.println("Excepcion de inactividad");
}
}
}
}

Corrida y descripcin:

El programa proporciona un botn llamado Iniciar que hace que la pelota empiece a rebotar.

Hay retraso en el programa para que la pelota no vaya demasiado rpido.


Para ello, el programa invoca al mtodo de biblioteca sleep. El parmetro que pasa a sleep
representa el tiempo en milisegundos que el programa debe estar inactivo. Para utilizar este mtodo
debe proporcionarse tambin un manejador de excepciones, como se muestra en el cdigo. Otra
caracterstica de este programa es que el contexto de grficos, g, se pasa del objeto de interfaz de
usuario al objeto pelota cuando este se crea mediante su funcin constructora.
Solucin:
Es crear dos subprocesos: uno para manejar la interfaz de usuario (botones, etcetera) y el otro para
dibujar la animacin.
El objetivo es que el programa de la pelota rebotadora no monopolice la computadora, para eso se
crearan dos subprocesos que se ejecuten al mismo tiempo. Uno es, como siempre, el objeto de
interfaz de usuario. Este se encarga de crear los dems objetos y luego esperar a que ocurra algn
otro evento, que posteriormente manejara. El otro subproceso dibuja la pelota rebotadora.
El primer objeto de interfaz de usuario crea al segundo subproceso. De ah en adelante, los dos se
ejecutan en forma conjunta, compartiendo el procesador. El subproceso de la pelota rebotadora

permanece inactivo en forma peridica durante 50 milisegundos. Esto es muy importante para que
la interfaz de usuario pueda obtener algo de tiempo de procesador para ejecutarse.
La clase (y subprocesos) de interfaz de usuario es, como siempre, una extensin de la clase de
biblioteca Applet. La otra clase (subproceso) es una extensin de la clase de biblioteca Thread. El
nico requerimiento de esta clase es que debe proporcionar un mtodo llamado run. Este mtodo es
invocado por el sistema Java para ejecutar al subproceso. Pero de la creacin del subproceso se
encarga el objeto de interfaz de usuario. Primero crea al nuevo objeto, justo igual que como se crea
cualquier otro objeto, con:
Pelota pelota = new Pelota (g);
Luego pide al sistema de Java que ejecute el subproceso, utilizando el mtodo de biblioteca
start:
pelota.start ( );
Camiones (Central de autobuses)
Objetivo: Implementar el problema del estacionamiento usando la sincronizacin, dando una salida
satisfactoria
Cdigo:
import java.io.*;
public class Autobus {
public static void main(String args[]) {
terminal t = new terminal();
llenar l = new llenar(t);
vaciar v = new vaciar(t);
l.start();
v.start();
}
}
class llenar extends Thread {
private terminal term;
public llenar (terminal r) {
this.term = r;
}
public void run() {
for (int i=0; i<=39; i++) {
// control de pasajeros
term.entra (new Integer(i));
System.out.println ("El pasajero " + i + " llega a la
terminal.");
try {
sleep ((int)(Math.random() * 300));
} catch (InterruptedException e) {}
}
}
}
class vaciar extends Thread {
private terminal termin;
public vaciar (terminal r) {

this.termin = r;
}
int i = 0;
public void run() {
while (i <= 3) {
termin.salida();
System.out.println ("El camion " + i + " ha salido con 10
personas.");
i++;
}
}
}
class terminal {
private boolean lleno = false;
private ColaEnlazada tail = new ColaEnlazada();
public synchronized void salida() {
while (!lleno) {
try {
wait();
} catch (InterruptedException e) {}
}
tail.Vaciar();
lleno = false;
notify();
}
public synchronized void entra (Object o) {
if (tail.Size() != 10) {
while (lleno) {
try {
wait();
} catch (InterruptedException e) {}
}
tail.Insertar(o);
} else {
lleno = true;
notify();
}
}
}
class ColaEnlazada {
Nodo frente, fondo;
int size;
public ColaEnlazada () {
frente = null;
fondo = null;
size = 0;
}
int Size () {

return size;
}
boolean isEmpty () {
if (size == 0) return true;
else return false;
}
void Vaciar () {
frente = null;
fondo = null;
size = 0;
}
void Insertar (Object o) {
Nodo temp = new Nodo();
temp.setInfo (o);
if (isEmpty()) {
frente = temp;
fondo = temp;
}
else {
fondo.setProx (temp);
fondo = temp;
}
size ++;
}
Object Extraer () {
Object info;
info = frente.getProx();
frente = frente.getProx();
size--;
return info;
}
}
class Nodo {
private Object info;
private Nodo prox;
Nodo() {
info = null;
prox = null;
}
void setInfo (Object o) {
info = o;
}
void setProx (Nodo temp) {
prox = temp;
}
Object getInfo() {
return info;
}

Nodo getProx() {
return prox;
}
}
Corrida:

Conclusin:
En la programacin concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semforos, monitores, sincronizacin, etc. En este caso usamos
mtodos sincronizados para nuestro fin.