Download REPORTE CON SINCRONIZACION

REPORTE CON SINCRONIZACION
Antropófagos (Caníbales)
Objetivo: Implementar el problema de los antropófagos (Caníbales) usando la sincronización,
dando una salida satisfactoria.
Código:
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:
Conclusión:
En la programación concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semáforos, monitores, sincronización, etc. En este caso usamos
métodos sincronizados para nuestro fin.
Filósofos
Objetivo: Implementar el problema de los filósofos usando la
sincronización, dando una salida satisfactoria
Código:
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:
Conclusión:
En la programación concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semáforos, monitores, sincronización, etc. En este caso usamos
métodos sincronizados para nuestro fin.
Lectores y escritores
Objetivo: Implementar el problema de lectores y escritores usando la sincronización, dando una
salida satisfactoria
Código:
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:
Conclusión:
En la programación concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semáforos, monitores, sincronización, etc. En este caso usamos
métodos sincronizados para nuestro fin.
Rebotador
La entidad básica a la que el sistema operativo asigna tiempo de CPU. Un subproceso puede
ejecutar cualquier parte del código de una aplicación, 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 rectángulo en la pantalla.
Problema:
El problema con este programa es que, mientras la pelota se encuentra rebotando, nada mas puede
ocurrir.
Código:
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 descripción:
El programa proporciona un botón llamado “Iniciar” que hace que la pelota empiece a rebotar.
Hay retraso en el programa para que la pelota no vaya demasiado rápido.
Para ello, el programa invoca al método de biblioteca sleep. El parámetro que pasa a sleep
representa el tiempo en milisegundos que el programa debe estar inactivo. Para utilizar este método
debe proporcionarse también un manejador de excepciones, como se muestra en el código. Otra
característica de este programa es que el contexto de gráficos, g, se pasa del objeto de interfaz de
usuario al objeto pelota cuando este se crea mediante su función constructora.
Solución:
Es crear dos subprocesos: uno para manejar la interfaz de usuario (botones, etcetera) y el otro para
dibujar la animación.
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 demás objetos y luego esperar a que ocurra algún
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 periódica 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 extensión de la clase de
biblioteca Applet. La otra clase (subproceso) es una extensión de la clase de biblioteca Thread. El
único requerimiento de esta clase es que debe proporcionar un método llamado run. Este método es
invocado por el sistema Java para ejecutar al subproceso. Pero de la creación 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 método de biblioteca
start:
pelota.start ( );
Camiones (Central de autobuses)
Objetivo: Implementar el problema del estacionamiento usando la sincronización, dando una salida
satisfactoria
Código:
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:
Conclusión:
En la programación concurrente existen varias maneras de hacer que un programa haga lo que se
piensa; tales recursos son los semáforos, monitores, sincronización, etc. En este caso usamos
métodos sincronizados para nuestro fin.