03.g Implementación del buffer tipo LIFO (La pila, último en llegar es primero en salir) (324) La bibliotecaria recibirá libros nuevos para catalogar y los enviará a apilar en el escritorio de la asistente, la asistente tendrá un minuto para leer el nombre de la etiqueta que envió la biblioteca contact Created,Modified 2009-04-02 11:53:56, 2009-05-07 19:09:58 Author,Nick Gustavo Guillermo Perez, (madgus) [myblog]

Implementación del buffer tipo LIFO (La pila, último en llegar es primero en salir)

Modifiquemos el ejemplo anterior para que ahora sean una bibliotecaria y su asistente, la bibliotecaria recibirá libros nuevos para catalogar y los enviará a apilar en el escritorio de la asistente, la asistente tendrá un minuto para leer el nombre de la etiqueta que envió la bibliotecaria a través de la red y ordenarlo, es visto que los libros ahora saldrán en forma de pila y no cola de espera, el límite será la altura de la asistente que hace las tarjetas sentada, pero no lo calcularemos :p.

Libros en total 24, se envía el contenido de la tarjeta en modo texto.

Asistente:

gus@gusgus ~$ java com.compunauta.aprendiendojava.Cap3_lifo_asis

Escuchando el puerto:4567

Esperando conexión...

Conectado... Esperando títulos

Libro:Introducción a la física

No hay más, nos vamos cuando terminemos...

Libro:Aprendiendo Java

Libro:Lectura I

Libro:Asambleas

Ya no es necesario esperar, terminado...

gus@gusgus ~$

Bibliotecaria:

gus@gusgus ~$ java com.compunauta.aprendiendojava.Cap3_lifo_bib

Intentando conectar con la asistente

Nos conectamos con la asistente:127.0.0.1:4567

Ingrese Títulos (línea vacía termina)

Introducción a la física

Asambleas

Lectura I

Aprendiendo Java

Programa terminado

gus@gusgus ~$

Asistente:

1. package com.compunauta.aprendiendojava;

2. import java.io.*;

3. import java.net.*;

4. /**

5. * <p>Título: Aprendiendo Java</p>

6. * <p>Descripción: Ejemplos del Libro Aprendiendo Java de Compunauta</p>

7. * <p>Copyright: Copyright (c) 2006 www.compunauta.com</p>

8. * <p>Empresa: COMPUNAUTA</p>

9. * @author Gustavo Guillermo Pérez

10. * @version 2006.01.01

11. */

13. public class Cap3_lifo_asis {

14. //Declaramos unas variables globales a este tipo de datos

15. public static int PORT=4567;

16. public static int BUFF_SIZE=24;

17. public static int TIMER_SLEEP=60*1000; //60sx1000ms

18. public static int buff_elem=0;

19. public static String[] buffer=new String[BUFF_SIZE];

21. public static void main(String[] args) {

22. //Declaramos la variable socket (será un puntero a objeto)

23. Socket skt=(Socket)null;

24. //Declaramos vacío el servidor de sockets para inicializarlo

25. ServerSocket Ss=(ServerSocket)null;

27. //Tratamos de escuchar el puerto definido por la variable PORT

28. System.err.println("Escuchando el puerto:"+PORT);

29. try {Ss = new ServerSocket(PORT);}

30. catch (IOException ex) {

31. System.out.println("El sistema no permite abrir el puerto");

32. System.exit(-1);}

34. //Si no ocurrió error arriba entonces esperamos a la secretaria

35. System.err.println("Esperando conexión...");

36. try {skt = Ss.accept();}

37. catch (IOException ex1) {

38. ex1.printStackTrace(System.err);

39. System.exit(-1);}

41. //Si no ocurrió error arriba la secretaria está lista para enviar

42. System.err.println("Conectado... Esperando títulos");

43. try {

44. BufferedReader datos = new BufferedReader(new InputStreamReader((skt.getInputStream())));

45. long timer=0;

46. boolean timer_on=false;

47. boolean ultimo=false;

48. while (true){

49. if(!ultimo && (skt.isClosed() || ((buff_elem>0) && buffer[buff_elem-1]!=null && buffer[buff_elem-1].equals("fin")))){

50. //Terminamos el programa si la bibliotecaria terminó

51. System.err.println("No hay más, nos vamos cuando terminemos...");

52. //el libro fin no se debe guardar es el aviso

53. buff_elem--;

54. ultimo=true;

55. }

56. if(ultimo && (buff_elem==0)){

57. System.err.println("Ya no es necesario esperar, terminado...");

58. System.exit(0);}

59. //si hay títulos los guardamos

60. if(!ultimo && datos.ready()){

61. put_tit(datos.readLine());}

62. if(timer_on){

63. //si el timer funciona no hacer nada, si se pasó pararlo

64. if ((timer+TIMER_SLEEP)<System.currentTimeMillis()){timer_on=false;}

65. }else{

66. //Si el timer está apagado, mostramos un tel si es que hay

67. if (buff_elem>0){System.out.println("Libro:"+get_tit());

68. //Encendemos el timer y guardamos la hora en que empezó

69. timer_on=true;

70. timer=System.currentTimeMillis();}

71. }

72. //Pausamos 100ms para no sobrecargar el procesador

73. try {Thread.sleep(100);}

74. catch (InterruptedException ex3) {}

75. }//fin del bloque eterno

76. }catch (Exception ex2) {

77. ex2.printStackTrace(System.err);

78. System.exit(-1);

79. }

81. }//fin del método principal

82.  

84. //Funciones o métodos auxiliares

85. public static void put_tit(String tit){

86. //Si se supera el espacio producir un error

87. if (BUFF_SIZE<(buff_elem+1)){

88. System.err.println("Buffer overrun: El buffer se llenó demasiado rápido");

89. System.exit(-1);}

90. //guardamos el tel y aumentamos en uno el contador

91. buffer[buff_elem++]=tit;

92. }

94. public static String get_tit(){

95. //quitamos uno al contador de elementos

96. //devolvemos el último libro

97. return buffer[--buff_elem];

98. }

100. }//final de la clase

 

Descripción del funcionamiento:

La declaración de variables globales a la clase o tipo de datos se realiza entre las líneas 15 y 19.

El método principal comienza en la línea 21, y declaramos los objetos del tipo Socket y ServerSocket como en el apartado anterior.

Desde la línea 28 a la 32 intentamos abrir el puerto para escuchar conexiones entrantes, si sucede un error nos salimos.

Si no hay errores, entre la línea 35 y 38 esperamos una conexión entrante con su respectivo bloque de control de errores.

Como la función accept();detendrá el programa hasta que arribe una conexión, si estamos ejecutando el bloque principal entre las líneas 43 y siguientes, es porque se recibió una conexión. En el respectivo bloque de control de errores iniciamos el flujo de datos que usaremos para ir recibiendo renglones, en este caso usamos el mismo tipo de objeto que nos permite leer líneas desde el teclado, solo que ahora las leeremos desde la conexión de red.

Declaramos algunas cuantas variables para crear nuestro temporizador de 1 minuto igual que en el ejemplo anterior, y definimos una variable ultimo que nos avisará cuando los libros son todos.

En este caso la bandera que usamos para saber que hemos terminado por parte de la bibliotecaria es la palabra clave “fin”, y por supuesto revisamos que la conexión no esté cerrada, que haya elementos y todo eso antes de proceder a retirar un libro del buffer y enseñarlo en pantalla. La bandera binaria ultimo solo se activará en la condición anterior para asegurar que seguiremos mostrando títulos mientras, es una variación respecto del ejemplo anterior para ver otras maneras de resolver algo similar.

Si, el ultimo elemento ya llegó y no hay más en la memoria temporal, entonces nos salimos del programa. (líneas 56-58).

Si no es el ultimo elemento y hay datos disponibles en el flujo de datos de red, entonces leer una línea y ponerla en la memoria temporal.

Si el timer está encendido entonces procedemos igual que antes, el único cambio sustancial serán las funciones que guardan y extraen los datos del buffer.

La única función que cambia es la que quita elementos del buffer, que es mucho más simple que antes.

return buffer[--buff_elem];

Donde estamos decrementando el contador de elementos antes (el -- está a la izquierda) y como sabemos que los arreglos se acceden desde el 0 a cantidad-1 entonces es correcto el resultado devuelto.

leavecomment

---