PDF de programación - INVESTIGACIÓN DE APPLETS EN JAVA

Universidad Nacional del Nordeste

Facultad de Ciencias Exactas y Naturales y

Agrimensura

Monografía de Adscripción

Asignatura: Sistemas Operativos



INVESTIGACIÓN DE APPLETS
INVESTIGACIÓN DE APPLETS
INVESTIGACIÓN DE APPLETS
INVESTIGACIÓN DE APPLETS

EN JAVA
EN JAVA
EN JAVA
EN JAVA



APELLIDO Y NOMBRE:::: Rodríguez Nelson Fabián
Rodríguez Nelson Fabián
Rodríguez Nelson Fabián
Rodríguez Nelson Fabián



L.U: 32945
32945
32945
32945

PROF. DIRECTOR: David Luis La Red Martinez
David Luis La Red Martinez
David Luis La Red Martinez
David Luis La Red Martinez

LICENCIATURA EN SISTEMAS DE INFORMACIÓN
LICENCIATURA EN SISTEMAS DE INFORMACIÓN
LICENCIATURA EN SISTEMAS DE INFORMACIÓN
LICENCIATURA EN SISTEMAS DE INFORMACIÓN

Corrientes ---- Argentina
Corrientes
Argentina
Corrientes
Corrientes
Argentina
Argentina

2008
2008
20082008






Este trabajo práctico de Adscripción consiste en la investigación, análisis y desarrollo

Introducción

de los diferentes casos de estudio propuestos en el SistOper, se han desarrollados
applets utilizando el lenguaje Java y como IDE a NetBeans, una poderosa herramienta

para el desarrollo de aplicaciones orientadas a objetos y el desarrollo de applets para su

utilización en Internet.

Los casos de estudio desarrollados fueron: Hilos en Java, Algoritmos de Planificación

del Procesador y Anomalía Belady, este informe consta de un marco teórico de cada

caso de estudio, el código desarrollado y cada una de las ventanas de los applets.

Hilos en JAVA


Concurrencia e Hilos con Java

Los hilos o procesos ligeros son una parte de código o mini programa que puede ser

ejecutada independientemente, de forma que una aplicación o un applet puede tener

varios hilos ejecutándose simultáneamente y efectuando distintas tareas; estos hilos se

encuentran dentro de un programa y son parte de él.

Los hilos, a veces también llamados contextos de ejecución, pueden ser utilizados para

la implementación de algoritmos paralelos o procesos concurrentes, sin ser necesario

disponer de equipos con estructura de multiprocesador. En el caso de un solo

procesador,

los procesos

ligeros

incorporan mecanismos para compartirlo,

estableciéndose prioridades entre ellos y también facilidades de sincronización, cuando

es necesario.

Objetivo del Caso de Estudio

El objetivo de este caso de estudio fue el de desarrollar un applet que implementara el

problema de “procesos productores y consumidores” y que permitiera generar en un
arreglo el seguimiento de dicha simulación y posteriormente efectuar análisis de la

forma en que se ha desarrollado la ejecución concurrente de los hilos y la sincronización

de los mismos, que es el verdadero objetivo, más allá de la utilización como ejemplo del

problema de productores y consumidores.


Descripción de los Algoritmos Utilizados

Respecto del algoritmo de productores y consumidores utilizado como base para el
desarrollo del programa del caso de estudio
Los principales aspectos del algoritmo desarrollado son los siguientes:
Los procesos productores simulan generar, es decir “grabar” información en un

grupo de buffers disponibles.


Los procesos consumidores simulan retirar, es decir “leer” información del grupo de
buffer disponibles, que previamente debió ser “cargado” por los procesos
productores.


Los procesos consumidores solo pueden “leer” información previamente “grabada”

por los procesos productores.

Si cuando un proceso consumidor intenta leer no hay suficientes buffers disponibles,

debe esperar a que alguno de los procesos productores grabe los buffers.


Los procesos productores solo actúan cuando el nivel de buffers grabados está por
debajo de cierto límite, llamado límite de reposición, que es un dato variable que se
ingresa como parámetro de configuración de la simulación, al igual que la cantidad
de buffers grabados en cada reposición.


Los procesos consumidores pueden retirar (leer) buffers en número variable pero
hasta cierto límite, que también es un dato variable que se ingresa como parámetro
de configuración de la simulación.


Debido a que los procesos productores solo actúan cuando el número de buffers
disponibles está por debajo del nivel de reposición y a que la cantidad de reposición
es finita, se asegura que el número de buffers del pool será siempre finito.


El tiempo que dura la simulación también es un parámetro de configuración que se

ingresa como dato expresado en milisegundos.



Applet Desarrollado

El applet desarrollado recibe como entradas por pantalla los datos de configuración de

la simulación referidos a:
Número inicial de buffers ocupados.
Número máximo de buffers leídos por vez.
Número mínimo de buffers ocupados antes de grabar más.
Número de buffers grabados por vez.
Número de milisegundos de la ejecución.

Respecto del arreglo generado, el mismo tendrá un tamaño variable según los datos que

se hayan suministrado a la ejecución que lo produce, especialmente el tiempo de

ejecución; es preciso señalar además que el arreglo se aloja en la memoria temporal, es

decir que se borra terminar cada ejecución.

El código del applet desarrollado es el siguiente:

import java.io.*;
import java.util.*;
import java.util.Date;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.applet.*;
import java.applet.Applet;
import java.math.*;
import java.text.*;
import java.lang.String;
import java.lang.*;


class Almacen {
public int stock=0;
private boolean necesitareponer;
public boolean cerrado=false;
public int MAXCOMPRA=0;
public int LIMITEREPONER=0;
public int CANTIDADREPONER=0;
public long TIEMPOAPERTURA=0;
long hora=System.currentTimeMillis();

ArrayList datos;
public Almacen(ArrayList datos){
this.datos = datos;
}

public synchronized void comprar(int consumidor,
int cantidad) {
while (necesitareponer == true) {
try {
wait();
} catch (InterruptedException e) {}
}

if(!cerrado){
if(stock<cantidad){



cantidad=stock;



datos.add(c);


if(stock<=LIMITEREPONER)
necesitareponer = true;


unidades.";



}
notify();
}

public synchronized void reponer(int productor) {
if (!cerrado){
while (necesitareponer == false){



try {
wait();
} catch (InterruptedException e) {}
}
stock+=CANTIDADREPONER;



}
stock-=cantidad;
String c;
c = "Quedan " + stock + " unidades. El Consumidor " + consumidor + " ha leido " +cantidad+"



try {
String c;
c = "Quedan " + stock + " unidades. El Productor " + productor + " ha grabado " +

CANTIDADREPONER + " unidades.";



datos.add(c);
}catch (Exception e) {
System.out.println("Archivo Hilos: Salida luego de grabar Hilo Productor: " + e);
}



notify();
}
}

class Consumidor extends Thread {
private Almacen almacen;

necesitareponer = false;
}

private int numero;

public Consumidor(Almacen a, int numero) {
almacen = a;
this.numero = numero;
}

public void run() {
int value;
while(!almacen.cerrado){
value=(int)(Math.random()*almacen.MAXCOMPRA);
almacen.comprar(numero,value);
}
}
}

class Productor extends Thread {
private Almacen almacen;
private int numero;
private ArrayList datos;

public Productor(Almacen a, int numero, ArrayList datos) {
this.datos = datos;
almacen = a;
this.numero = numero;
}

public void run() {
while(!almacen.cerrado){
if(System.currentTimeMillis()-almacen.hora>almacen.TIEMPOAPERTURA){
almacen.cerrado=true;



c = "Fin de la ejecución.";



almacen.reponer(numero);

try {
sleep((int)(Math.random() * 100));
}catch(InterruptedException e) {}
}
}
}


class VImaCanvas extends Frame
implements AdjustmentListener {

Image imagen1;
ImaCanvas imaani;
Panel panel;

public VImaCanvas(){
setLayout(new BorderLayout());
panel = new Panel();
// Agregado de la imagen animada.
imagen1 = Toolkit.getDefaultToolkit().getImage("imagen1.gif");
imaani = new ImaCanvas(imagen1);
panel.add(imaani);


try {

String c;



datos.add(c);
}catch (Exception e) {
System.out.println("Archivo Hilos: Salida luego de grabar Fin de la ejecución: " + e);
}
}



add("Center",imaani);



private Button btn;
private VImaCanvas imagen1;



}

if(eve.getSource() == btn){


// Creación del menú principal.

addWindowListener(new WindowAdapter() {

((Frame)e.getSource()).dispose();

btn = new Button("Presione");
btn.addActionListener(this);
this.add(btn);

public void init() {



}

public void actionPerformed(ActionEvent eve){



public void windowClosing(WindowEvent e) {


}
});


}