FACULTAD DE INGENIERIA DE SISTEMAS E.A.P INGENIERIA DE SISTEMAS E INFORMATICA
“ TAREA Nº-2 DE SISTEMAS OPERATIVOS”
CURSO
:
SISTEMAS OPERATIVOS
TEMA
:
ADMINISTRADOR DE TAREAS
PROFESORA
:
MARIA ELENA RUIZ RIVERA
ALUMNOS
:
MONDRAGON PANTIGOSO, MARCO GIMENEZ ALATA, RICARDO
CIUDAD UNIVERSITARIA, NOVIEMBRE DEL 2011
Tabla de contenido Tabla de conteni contenido do........ ................ ............... ............... ................ ............... ............... ................ ................ ............... ............... ............... ......... .. 2 1. Objetivo ........ ................ ................ ............... ............... ................ ............... ............... ................ ................ ............... ............... ................ ............. .......3 2. Explicación del de l programa (¿Qué (¿Qu é es lo que hace?) ........ ................ ................ ............... ............. .......... ...... ..3 3. Código....... ............... ................ ............... ............... ................ ............... ............... ................ ................ ............... ............... ............. ......... ........ ...... .. 18 4. Conclu Conclusiones siones ....... ............... ................ ................ ............... ............... ................ ............... ............... ................ ............ ........ ........ ........ ........ .... 46
1. Objetivo Implementar un administrador de tareas bajo el S.O. Windows XP que nos permita visualizar los procesos que hayan sido llevados a memoria principal, siendo capaces de observar a manera de lista y de forma gráfica los nombres, tamaños y el PID de estos procesos en tiempo real. Por otro lado, la asignación de memoria de trato de forma continua y su representación en memoria (direcciones físicas) se hizo mediante registros (base, límite) y el tamaño que ocupa (el proceso) en memoria (desplazamiento). Para desarrollar la aplicación se utilizó el lenguaje Java y el IDE Netbeans 6.5. Los temas abarcados son: POO (clases), hilos, Java swing y Java 2d.
2. Explicación del programa (¿Qué es lo que hace?) Primero, en nuestra interfaz nos vamos a la pestaña de procesos, en ella
podemos visualizar la lista de procesos que se están cargadas en memoria todo ello gracias al comando tasklist del cmd (ms-dos). De donde obtuvimos el nombre del proceso, su PID, nombre de usuario (sesión), número de sesión y el uso de memoria que utiliza el proceso en memoria real. Su implementación se llevó a cabo mediante un hilo llamado Clase Hilo el cu al monitorea constantemente por los cambios en el número de proceso y actualiza la lista y sus campos. El cual a su vez llama al método procesar que se encarga de separar cada línea línea de comando leída leída por el tasklist.()
(Fig.1) Ejemplo: se separa la línea 1 hasta la línea n(# procesos en memoria) todos sus campo. A manera de ejemplo la línea se separaría así (System Idle Idle Process –PID-Nombre – número de sesión- uso de memoria) y estos
campos son almacenados en el Jtable tabla_procesos de la Fig.2. Asimismo, este método procesar también nos sirve para llenar el JTable tabla_aplicaciones de la pestaña Aplicaciones (Fig.3).
(Fig. 2)
(Fig. 3) Cabe resaltar que la pestaña de Aplicaciones se actualiza del mismo método procesar, el cual es lee el proceso. Ejemplo: netbeans.exe y nosotros detectamos esta cadena si esto sucede entonces procedemos a llenar con estos datos la tabla_aplicaciones . Por lo que este Jtable está sujeto a las aplicaciones para los procesos que nosotros hayamos definido, esto es, solo se mostraran las aplicaciones para los cuales exista su equivalente (ver Fig. 4).
(Fig.4) Segundo, la pestaña memoria nos muestra la memoria RAM total, memoria
RAM libre y la memoria usada mediante un hilo llamado hmemoria de la clase Hilo_memoria que mediante la librería hyperic-sigar-1.6.4, específicamente el jar de sigar.jar que contiene la clase Sigar y esta a su vez contiene la clase Mem cuyos métodos: getTotal(),getFree(),getUsed() nos permiten saber que cantidad de memoria se está utilizando(ver Fig.5) . Long memTotal=memoria.getTotal(); Long memLibre=memoria.getFree(); Long memUsada=memoria.getUsed(); (Fig. 5) En la misma ventana disponemos de los botones iniciar gráfica y detener gráfica de los cuales iniciar gráfica dibuja en el Jpanel gráfica( mediante La clase Graphics de la librería Java2d) utilizándolo como superficie de dibujo a este panel. Lo que hacemos es dibujar rectángulos con el método fillRect(int x, int y, int width, int height) cuyos puntos x,y es el vértice superior izquierdo del rectángulo y width viene a ser el ancho y height el alto todos ellos en pixeles (tipo entero). Donde cada entero representa un pixel donde cada punto se ubica de acuerdo a la figura 6(ver los ejes). La figura es similar al del panel.
(Fig. 6) Partiendo del método procesar que vimos anteriormente hacemos lo siguiente: la primera vez que se inicie el método procesar se creará una lista de registros con los datos( nombre, registro base, desplazamiento y registro límite) de los procesos. Luego de creada esta lista de Nodos llamada lista_registro de la clase Lista_Reg está nos servirá para realizar la gráfica resumen de todos los procesos (que se encuentren en la lista) guardando una proporción con su tamaño en píxeles. Como dijimos esta lista solo se creará la primera vez(utilizando el método agregarNodo() de la lista por cada proceso) mediante un uso del booleano primeraVez para las veces siguientes si es que se detecta una modificación en la lectura de procesos (actualización lista agregaron o finalizaron procesos) y se buscará en la misma lista ya creada línea por línea cada proceso leído por el comando cmd tasklist y si el nombre del proceso no se encuentra en la lista_registro se agrega un nuevo nodo con los datos mencionados anteriormente en el primer espacio en donde quepa el proceso(ver línea 474 de la clase Admin.java del método procesar).
(Fig. 7) Una vez explicado esto veamos la gráfica resumen de la Fig.8 generada (click en iniciar gráfica). Por otro lado el botón detener gráfica lo que hace es resetear los valores del Jpane con el método (grafica.updateUI()).
(Fig. 8)
Tercero, la pestaña Usuario nos muestra la cuenta de usuario usada para entrar
a Windows con el método del Frame Principal (InformacionUsuario()) el cual a su vez hace uso del método System.getProperty("user.name"). Cuarto, la pestaña de registros contiene un Jtable llamado tabla_registros el
cual se llena cuando presionamos el botón de ver en consola los registros. Este JTable toma los datos de la lista_registros(el cual contiene todos los campos que aparecen aquí, ver los atributos de la clase Nodo) que es la que se actualiza a cada momento por se encuentra en el método procesar del Hilo(ver Fig.11). Para visualizar el gráfico de la parte inferior del uso de la memoria, solo debemos de ingresar el mouse al área del JScrollPane(jScrollPane5) en cuyo interior se encuentra un JPane(grafica2). Esta área se pintará automáticamente cada vez que lo ingresemos el cursor del mouse OJO(ver Fig.9).
(Fig. 9) En la figura 10 podemos visualizar el área libre de la RAM y esta se cálcula de la misma manera que se calculó en el método informaciónMemoria() del hilo hmemoria (con la librería del Sigar.jar). Por otro lado, se sumó recorriendo la lista_registros los desplazamientos y a la cantidad de memoriaTotal se le resto esta suma dándonos la memoriaLibre y ese espacio se puede ver en la fig. 10. Cabe mencionar que estos desplazamientos son tan diversos en tamaño que
para fines didácticos y para poder visualizar mejor los tamaños de los rectángulos se hizo uso de intervalos si el proceso es menor a 25 000Kb es de tamaño pequeño (ancho de 150 píxeles), si esta entre 25 000Kby 50 000Kb es de tamaño intermedio (ancho de 300 píxeles) y si es mayor a 50 000Kb entonces es de tamaño grande (ancho de 450 píxeles). (Ver método sumaDesplazamiento2() de la clase Lista_Reg).
(Fig. 10)
(Fig. 11)
(Fig.12)
Quinto, probaremos al mismo tiempo si se actualiza la gráfica cuando se
finalice un proceso y cuando se agregue uno nuevo este busque el primer espacio vacío que se adecúe a su su tamaño y que cuando se libere un proceso y este se encuentre al lado de otro vacío (seguidos) se condensen los espacios vacíos en uno solo. Vallamos paso a paso con las siguientes imágenes explicando este ejemplo del paso cinco.
(Fig. 13) En la fig. 13 se aprecia el proceso notepad.exe y este se va a finalizar(click en archivo y de ahí en finalizar tarea, se va a abrir una ventana como en la en la fig 14.) A continuación escribir su nombre n ombre sin el .exe (del proceso). proceso) . Y click el matar proceso. Luego entrar el cursor en la zona de la gráfica para que se repinte el área (fig. 15)
(Fig. 14)
(Fig. 15) Para probar la condensación veremos una secuencia rápida de imágenes (Fig 16-20). Con el notepad ya abierto y después de ejecutada la aplicación se tiene lo de la fig.16.
(Fig. 16)
(Fig.17) Luego de haber finalizado el notepad(Fig.17) se puede visualizar en la gráfica esta actualización al haber entrado el cursor en el área, pero no olvidar que para que actualice la tabla del JTable debemos hacer click en el botón en ver en consola los registros. NO OLVIDAR. Nosotros si hicimos click en este botón por eso es que sale actualizada la tabla, pero ambas el JTable y el Jpane se actualizan con los datos de la lista_registros (Nodos).
Probamos a abrir un programa que es el buscaminas winmine.exe y como vemos en la fig.18 este se aloja en el primer espacio que se adecúe a su tamaño el cual como se aprecia es el espacio libre que quedo vacío tras haberse liberado el notepad. En esta figura (#18) si se le dio click al botón ver en consolado los registros es por eso que la tabla si aparece como actualizada.
(Fig. 18) Si matamos al winmine(buscaminas) haciendo click en el menú Archivo>Finalizar Tarea y escribimos winmine y click en matar proceso vamos a tener lo que vemos fig.19. Sólo que en la fig. 19 no le dimos click al botón no alarmase (este cambio más rápido de lo que pudimos dar click en el botón ver en consola registros para actualizar la tabla). Y la condensación se realiza con un hilo (hcondensar ) que monitorea constantemente y cada ocho segundos está viendo si existen espacios contiguos y los condensa pasando de la figura 19 a la 20.
(Fig. 19)
(Fig. 20)
3. Código
************************CLASE Lista_Reg******************** package newpackage; import javax.swing.JTable; /** * * @author APOYO - UIC */ /*Registro límite = tamaño máximo del programa y los datos * Registro base =posición de inicio del programa en memoria*/ public class Lista_Reg { Nodo inicio;
Nodo fin; int total; public Lista_Reg(){ total=0; inicio=null; fin=null; } public void agregarNodo(String nom,int rb, int d, int rl){ total++; Nodo nodo=new Nodo(total, nom,rb,d,rl); if(inicio==null){ // si lista vacia crea el primer elemento, sino añade un nodo inicio=nodo; }else{ //ya existe al menos un nodo fin.setSig(nodo); } fin=nodo; } //para la consola public void recorrerLista(){ int i=1; Nodo p=new Nodo(); p=inicio; while(p!=null){ System.out.println("Proceso " +i); System.out.println("Nombre: "+p.getNombre()); System.out.println("R_base: "+p.getR_base()); System.out.println("Desplazamiento: "+p.getDesplazamiento()); System.out.println("R_limite: "+p.getR_limite()); p=p.getSig(); i++; } } //para el jTable public void recorreLLenar(JTable tabla,int maxFilas){ int i=0; Nodo p=new Nodo(); p=inicio; int num=1; while(p!=null&&i
p=p.getSig(); i++; num++; } if(i>=maxFilas){ System.out.println("Se alcanzo límite maximo de filas"); } } public boolean buscar(String nombre){ boolean encontro=false; Nodo p=new Nodo(); p=inicio; while(p!=null){ if(p.getNombre().equals(nombre)){ encontro=true; } p=p.getSig(); } return encontro; } public int sumaDesplazamiento(){ int suma=0; Nodo p=new Nodo(); p=inicio; while(p!=null){ if(!p.getNombre().equals("vacio")){ suma=suma+p.getDesplazamiento(); } p=p.getSig(); } return suma; } public int sumaDesplazamiento2(){ int suma=0; Nodo p=new Nodo(); p=inicio; while(p!=null){ int desp=450; if(p.getDesplazamiento()<25000){ desp=150; }else{ if(25000
50000 } suma=suma+desp; p=p.getSig(); } return suma;
} public void llenarBlanco(String cadena){ Nodo p=new Nodo(); p=inicio; while(p!=null){ if(p.getNombre().equals(cadena+".exe")|| p.getNombre().equals(cadena.toUpperCase()+".EXE")){ p.setNombre("vacio"); } p=p.getSig(); } }
}
***************************************************************** **************************CLASE NODO ******************** /* * To change this template, choose Tools | Templates * and open the template in the editor. */ package newpackage; /** * * @author APOYO - UIC */ public class Nodo { private String nombre; private int r_base; private int desplazamiento; private int r_limite; private int numero; private Nodo sig; int R; int G; int B; public Nodo(){ } public Nodo(int n,String nom,int rb, int d , int rl){ numero=n; R=(int) (Math.random() * 254 + 1); //1-254 G=(int) (Math.random() * 254 + 1); B=(int) (Math.random() * 254 + 1); nombre=nom; r_base=rb; desplazamiento=d; r_limite=rl; sig=null; }
/** * @return the nombre */ public String getNombre() { return nombre; } /** * @param nombre the nombre to set */ public void setNombre(String nombre) { this.nombre = nombre; } /** * @return the r_base */ public int getR_base() { return r_base; } /** * @param r_base the r_base to set */ public void setR_base(int r_base) { this.r_base = r_base; } /** * @return the desplazamiento */ public int getDesplazamiento() { return desplazamiento; } /** * @param desplazamiento the desplazamiento to set */ public void setDesplazamiento(int desplazamiento) { this.desplazamiento = desplazamiento; } /** * @return the r_limite */ public int getR_limite() { return r_limite; } /** * @param r_limite the r_limite to set */ public void setR_limite(int r_limite) { this.r_limite = r_limite; }
/** * @return the sig */ public Nodo getSig() { return sig; } /** * @param sig the sig to set */ public void setSig(Nodo sig) { this.sig = sig; } /** * @return the numero */ public int getNumero() { return numero; } /** * @param numero the numero to set */ public void setNumero(int numero) { this.numero = numero; } }
***************************************************************** **********************CLASE ADMIN************************* /* * To change this template, choose Tools | Templates * and open the template in the editor. */ /* * NewJFrame.java * * Created on 22/04/2011, 03:26:03 PM */ package newpackage; import com.sun.java.swing.plaf.windows.WindowsLookAndFeel; import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics; import java.io.BufferedReader; import java.io.File; import java.io.IOException;
import java.io.InputStream; import java.io.InputStreamReader; import java.util.logging.Level; import java.util.logging.Logger; import javax.swing.ImageIcon; import javax.swing.JFileChooser; import javax.swing.JOptionPane; import javax.swing.UIManager; import javax.swing.UnsupportedLookAndFeelException; import javax.swing.table.DefaultTableModel; import org.hyperic.sigar.Mem; import org.hyperic.sigar.Sigar; import org.hyperic.sigar.SigarException; /** * * @author User */ public class Admin extends javax.swing.JFrame { String noAgregar=" "; boolean pararGrafica=true; Hilo_memoria hmemoria=new Hilo_memoria(); Hilo_condensar hcondensar=new Hilo_condensar(); Sigar plugin= new Sigar(); int retVal=0;//valor del FileChooser int numP=0,numA=0; String nom_P = "", pid_P = "",nom_User ="" ,num_Sesion = "",mem = ""; String sesion_usuario; int conta=0; int procesos = 0; WindowsLookAndFeel win = new WindowsLookAndFeel(); ImageIcon im=new ImageIcon(getClass().getResource( ImageIcon(getClass().getResource("/Iconos/duke-small.png")); "/Iconos/duke-small.png")); private FechaHora fh=new FechaHora(); boolean primeraVez=true; DefaultTableModel dt=new DefaultTableModel(); Fecha fe = new Fecha(); HORA hor=new HORA(); Lista_Reg lista_registros=new Lista_Reg(); private String fileName; private JFileChooser FileC=new JFileChooser(); /** Creates new form NewJFrame */ public Admin() throws UnsupportedLookAndFeelException { UIManager.setLookAndFeel(win); initComponents();
FrameMatar.setVisible(false); setIconImage(im.getImage()); FrameMatar.setIconImage(im.getImage()); //SPlash window=new LW(this); //asignamos hora y fecha lblFecha.setText(fe.getFecha()); lblHora.setText(hor.getHora()); FileC.setVisible(false); //LLenado Tabla Procesos y Aplicaciones procesar(); // Informacion de memoria //hgrafica.start(); // InformacionMemoria(); //Inciar el hilo de memoria hmemoria.start(); //Informacion de Usuario InformacionUsuario(); //****************TAMAÑO //****************TAMAÑO DE LA GRAFICA JPANE DENTRO DEL JSCROLLPANE********* grafica2.setMinimumSize(new Dimension(4540, 400)); grafica2.setPreferredSize(new Dimension(4540, 400)); //jScrollPane5.setMinimumSize(new Dimension(18040, 400)); //jScrollPane5.setPreferredSize(new Dimension(18040, 400)); // grafica2.setMinimumSize(new Dimension((Integer.parseI Di mension((Integer.parseInt(dim)/10000)+50, nt(dim)/10000)+50, 400)); //grafica2.setPreferredSize(new //grafica2.setPreferredSize(new Dimension((Integer.parseInt(dim Dimension((Integer.parseInt(dim)/10000)+50, )/10000)+50, 400)); //******************* lblnum.setText("Aplicaciones :"); lblnum2.setText(numA+""); new Hilo().start(); hcondensar.start(); } public void InformacionUsuario(){ String a=System.getProperty("user.name"); a=System.getProperty("user.name"); tabla_usuario.setValueAt(a,0 ,0); tabla_usuario.setValueAt("0",0 ,1); tabla_usuario.setValueAt("Activo",0 ,2); tabla_usuario.setValueAt(sesion_usuario,0 ,3); } public void InformacionMemoria() throws SigarException{ Mem memoria=plugin.getMem(); Long memTotal=memoria.getTotal() memTotal=memoria.getTotal();; Long memLibre=memoria.getFree();
Long memUsada=memoria.getUsed(); lbltotal.setText(memTotal/1024+" Kb"); lbllib.setText(memLibre/1024+" Kb"); lbluso.setText(memUsada/1024+" KB"); } public class Hilo_memoria extends Thread{ @Override public void run(){ while(true){ try { //Modifica las etiquetas de memoria física. InformacionMemoria(); Hilo_memoria.sleep(1000); } catch (InterruptedException ex) { Logger.getLogger(Admin.class.getName()).log(Level.SEVERE, Logger.getLogger(Admin.class.getNam e()).log(Level.SEVERE, null, ex); } catch (SigarException ex) { Logger.getLogger(Admin.class.getName()).log(Level.SEVERE, Logger.getLogger(Admin.class.getNam e()).log(Level.SEVERE, null, ex); } } } } public void condensar(){ Nodo p=lista_registros.inicio; Nodo sig=p.getSig(); while(p!=null){ if(sig!=null){ if(p.getNombre().equals("vacio")&&sig.getNombre().equals("vacio")){ int sumaDesp=0; sumaDesp=p.getDesplazamiento()+sig.getDesplazamiento(); p.setDesplazamiento(sumaDesp); p.setR_limite(p.getR_base()+sumaDesp-1); p.setSig(sig.getSig()); } } if(p.getSig()==null){ lista_registros.fin=p; } p=p.getSig(); //pedir el siguiente solo si p es diferente de nulo if(p!=null){ sig=p.getSig(); } } } public class Hilo_condensar extends Thread{ @Override public void run(){ while(true){ try{ condensar(); Hilo_condensar.sleep(8000);
} catch (InterruptedException ex) { Logger.getLogger(Admin.class.getName()).log(Level.SEVERE, Logger.getLogger(Admin.class.getNam e()).log(Level.SEVERE, null, ex); } } } } public class Hilo_gráfica extends Thread{ int red=0; int green=0; int blue=0; int base_X=40; int base_Y=40; Nodo p=new Nodo(); @Override public void run(){ while(pararGrafica){ //dibujar en el canvas(jpane) de gráfica d e memoria //********************************* //************************************************** ******************** *** //CANVAS //****************modificado //****************modificado para la grafica2 Graphics m=grafica2.getGraphics(); m.setColor(Color.BLACK); m.fillRect(base_X,base_Y,700 ,200 ); //******************************** //************************************************* ***************** /*Pintaremos de la lista de registros *x cada registro un rectangulo. */ p=lista_registros.inicio; int anchoCanvas=650; //en realidad es 700 pero 50 es libre while(p!=null){ //*************GENERA //*************GENERA NUEVO N UEVO COLOR********** red=(int) (Math.random() * 255 + 1); //1-255 green=(int) (Math.random() * 255 + 1); blue=(int) (Math.random() * 255 + 1); Color pintura=new Color(red,green,blue); m.setColor(pintura); //***************************************** int ancho=(int) (lista_registros.sumaDesplazamiento()*p.getDesplazamiento()/anchoCanvas); int baseEnX=(int) (lista_registros.sumaDesplazamiento()*p.getR_base()/anchoCanvas); m.fillRect(base_X+baseEnX,base_Y, ancho,200 ); p=p.getSig(); } try { Hilo_gráfica.sleep(1000); //******************************** //************************************************** ********************** **** } catch (InterruptedException ex) {
Logger.getLogger(Admin.class.getName()).log(Level.SEVERE, Logger.getLogger(Admin.class.getNam e()).log(Level.SEVERE, null, ex); } //********************************** //**************************************************** ******************** ** } } } public class Hilo extends Thread{ public Hilo(){ } @Override /* Éste hilo lo que hace es llamar al método procesar * constantemente para que actualice los campos de la pestaña * procesos de la interfaz, es decir, si se ha agregado algún * proceso(cont>procesos) a eliminado(cont procesos || cont < procesos){ procesos = 0; procesar(); } //Hilo.sleep(2000); Hilo.sleep(10); //dormir el hilo 1000 equivale 1 segundo. } } } catch (InterruptedException ex) { ex.printStackTrace(); } } } public int leerProcesos(){ //Cuantos procesos existen se han creado int num_pro = 0; try{ Process pro=Runtime.getRuntime().exec ("cmd /c tasklist"); InputStream is = pro.getInputStream(); pro.getInputStream(); BufferedReader br = new BufferedReader (new InputStreamReader (is)); br.readLine(); br.readLine(); br.readLine(); while (br.readLine() != null){ num_pro++;
} } catch (Exception e){ e.printStackTrace(); } return num_pro; } public int separaNumero(String cadena){ int numero=0; String subcadena=""; for(int i=0;i
} if(nom_P.equalsIgnoreCase("ATVR1.exe")) {tabla_aplicaciones.setValueAt("Analog TVR",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("t2ev.exe")) {tabla_aplicaciones.setValueAt("Tarifador Telefónico",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("netbeans.exe")) {tabla_aplicaciones.setValueAt("Netbeans",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("winword.exe")) {tabla_aplicaciones.setValueAt("Microsoft Word",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("WINWORD.EXE")) {tabla_aplicaciones.setValueAt("Microsoft Word",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("powerpnt.exe")) {tabla_aplicaciones.setValueAt("PowerPoint",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("powerpnt.xe")) {tabla_aplicaciones.setValueAt("PowerPoint",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("excel.exe")) {tabla_aplicaciones.setValueAt("Microsoft Excel",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("EXCEL.EXE")) {tabla_aplicaciones.setValueAt("Microsoft Excel",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("notepad.exe")) {tabla_aplicaciones.setValueAt("Block de Notas",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("calc.exe")) {tabla_aplicaciones.setValueAt("Calculadora",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } if(nom_P.equalsIgnoreCase("mspaint.exe"))
{tabla_aplicaciones.setValueAt("Paint",y,0); tabla_aplicaciones.setValueAt("Activo",y,1); y++; } //***********TABLA DE PROCESOS******************* PROCESOS*************************** ******** tabla_procesos.setValueAt(nom_P,i,0); tabla_procesos.setValueAt(pid_P,i,1); tabla_procesos.setValueAt(nom_User,i,2); tabla_procesos.setValueAt(num_Sesion,i,3); tabla_procesos.setValueAt(mem,i,4); // Generamos la lista de nodos que nos servira para //la grafica de la memoria RAM if(primeraVez){ desplazamiento=separaNumero(mem); if(lista_registros.inicio==null){//1ero elemento r_base=0; r_limite=desplazamiento-1; }else{ r_base=lista_registros.fin.getR_limite()+1; r_limite=r_base+desplazamiento-1; } lista_registros.agregarNodo(nom_P, r_base,desplazamiento ,r_limite ); //para la primera vez de agregar Nodo //r_base=r_base+desplazamiento; //r_limite= }else{ //borrar o agregar del vector //borrar es poner a String "null" el nombre del proceso //agregar es poner al final de la lista //&&!nom_P.equals(noAgregar+".exe") boolean soloUna=true; if(!lista_registros.buscar(nom_P) if(!lista_registros.buscar(nom_P) ){ //no lo encontro, lo agrega System.out.println("nom_P ENTRO"); //lista_registros.agregarNodo(nom_P, r_base,desplazamiento ,r_limite ); //ahora asignar al primer hueco libre i ntroducirle el proceso //ACA AGREGAR EL CODIGO PARA QUE ACTUALICE EL TAMÑANO //DEL ULTIMO REGISTRO //debe buscar su hueco donde meterse primero int numero=lista_registros.total; lista_registros.total++; Nodo ant=new Nodo(); Nodo p=new Nodo(); p=lista_registros.inicio; ant=p; boolean salir=true; int tamVacio; desplazamiento=separaNumero(mem); while(p!=null&&salir){
//2 casos if(p.getNombre().equals("vacio")&&desplazamiento
*****************************************************************
4. Conclusiones Se logró cumplir con los objetivos pedidos para este trabajo del administrado de tareas los cuales eran ver los procesos en una lista, visualizar la cantidad de memoria RAM total, usada y libre, ver la lista de los registros para cada proceso en una tabla, y poder visualizar de manera gráfica como es que está siendo asigna la memoria RAM. Tan sólo nos faltó mejorar la rapidez de actualización (ingreso y borrado de datos) del Jtable tabla_registros. En conclusión, se logró lo propuesto y se aprendió que a medida que los sistemas operativos son más modernos estos consumen más memoria RAM (recursos) y por lo mismo cargan más procesos en memoria como es el caso del Windows 7 en comparación con el Windows XP. También hubo que trabajar con virtualización del d el S.O. Windows XP ya que ambos integrantes contaban con Windows 7 en sus Pc’s. Y al hacerlo descubrimos que el cmd/tasklist de estos SO virtualizados nos regresan los tamaños de los procesos con puntos. Ejemplos: 9.845Kb. Y los SO. Windows XP instalados como sistemas Operativos Host (principales como en el laboratorio) devolvían el tamaño de los procesos con comas. Ej: 9,675Kb. Tan solo hubo que hacer unos pequeños cambios en el código para poder superar esta barrera. También se tuvo dificultad para pintar la gráfica en el Jpane tuvo que ponerse un JScrollPane y dentro el JPane para poder gráficar la memoria RAM ya que sino la gráfica nos salía entrecortada y no se podía ver en su tamaño completo.