From d9e7508171e8fe07c630d56cf9cf5be5b64651a6 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 25 Sep 2024 18:45:42 +0200 Subject: [PATCH 01/22] Create readme.dx --- UA1/alex_jimenezR/readme.dx | 1 + 1 file changed, 1 insertion(+) create mode 100644 UA1/alex_jimenezR/readme.dx diff --git a/UA1/alex_jimenezR/readme.dx b/UA1/alex_jimenezR/readme.dx new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/UA1/alex_jimenezR/readme.dx @@ -0,0 +1 @@ + From fa5f6a3177b4b434574f857e0a18dd0b6b2f881e Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj Date: Wed, 2 Oct 2024 15:29:44 +0200 Subject: [PATCH 02/22] Cambio de nombre --- UA1/examen/{dev_0 => dev_13}/ua1ex1.c | 0 UA1/examen/{dev_0 => dev_13}/ua1ex1_teoria.txt | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename UA1/examen/{dev_0 => dev_13}/ua1ex1.c (100%) rename UA1/examen/{dev_0 => dev_13}/ua1ex1_teoria.txt (100%) diff --git a/UA1/examen/dev_0/ua1ex1.c b/UA1/examen/dev_13/ua1ex1.c similarity index 100% rename from UA1/examen/dev_0/ua1ex1.c rename to UA1/examen/dev_13/ua1ex1.c diff --git a/UA1/examen/dev_0/ua1ex1_teoria.txt b/UA1/examen/dev_13/ua1ex1_teoria.txt similarity index 100% rename from UA1/examen/dev_0/ua1ex1_teoria.txt rename to UA1/examen/dev_13/ua1ex1_teoria.txt From 9d0212a2887664c20d37a739cd4ea6f9f5f1a3c4 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj Date: Wed, 2 Oct 2024 15:35:10 +0200 Subject: [PATCH 03/22] Renombre de tareas --- UA1/tareas/{dev_0 => dev_13}/ua1tarea1.c | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename UA1/tareas/{dev_0 => dev_13}/ua1tarea1.c (100%) diff --git a/UA1/tareas/dev_0/ua1tarea1.c b/UA1/tareas/dev_13/ua1tarea1.c similarity index 100% rename from UA1/tareas/dev_0/ua1tarea1.c rename to UA1/tareas/dev_13/ua1tarea1.c From 9976fbb4053e706145978c44ece340836b03c4aa Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 2 Oct 2024 16:55:05 +0200 Subject: [PATCH 04/22] Update ua1tarea1.c --- UA1/tareas/dev_13/ua1tarea1.c | 46 ++++++++++++++++++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/UA1/tareas/dev_13/ua1tarea1.c b/UA1/tareas/dev_13/ua1tarea1.c index 1b2cfd02..3731b4a7 100644 --- a/UA1/tareas/dev_13/ua1tarea1.c +++ b/UA1/tareas/dev_13/ua1tarea1.c @@ -1 +1,45 @@ -Ya os gustaría \ No newline at end of file +#include +#include +#include +#include +#include + +int main() { + int numero; + pid_t pid; + + printf("Ingrese un número entero: "); + if (scanf("%d", &numero) != 1) { + fprintf(stderr, "Error: entrada no válida.\n"); + return EXIT_FAILURE; + } + + pid = fork(); + if (pid < 0) { + perror("Error al crear el proceso"); + return EXIT_FAILURE; + } + + if (pid == 0) { + variable += 4; + printf("Proceso hijo: Valor después de sumar 4: %d\n", numero); + exit(numero); + } else { + numero -= 5; + printf("Proceso padre: Valor después de restar 5: %d\n", numero); + + int estado; + waitpid(pid, &estado, 0); + + if (WIFEXITED(estado)) { + int resultado_hijo = WEXITSTATUS(estado); + printf("Proceso hijo terminó con el valor: %d\n", resultado_hijo); + } else { + fprintf(stderr, "El proceso hijo no terminó correctamente.\n"); + } + } + + printf("Valor final en el proceso padre: %d\n", numero); + + return EXIT_SUCCESS; +} From 694ce08c1a19fbaf42811cb711fb55336d51988f Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 2 Oct 2024 16:56:14 +0200 Subject: [PATCH 05/22] Correcion error ua1tarea1.c --- UA1/tareas/dev_13/ua1tarea1.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UA1/tareas/dev_13/ua1tarea1.c b/UA1/tareas/dev_13/ua1tarea1.c index 3731b4a7..e0ae20e0 100644 --- a/UA1/tareas/dev_13/ua1tarea1.c +++ b/UA1/tareas/dev_13/ua1tarea1.c @@ -21,7 +21,7 @@ int main() { } if (pid == 0) { - variable += 4; + numero += 4; printf("Proceso hijo: Valor después de sumar 4: %d\n", numero); exit(numero); } else { From 69f5edd3200829f33f3ef28a898f6abc86ca5b74 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 9 Oct 2024 15:06:50 +0200 Subject: [PATCH 06/22] Create tarea2 --- UA1/tareas/dev_13/tarea2 | 52 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 UA1/tareas/dev_13/tarea2 diff --git a/UA1/tareas/dev_13/tarea2 b/UA1/tareas/dev_13/tarea2 new file mode 100644 index 00000000..c239caf6 --- /dev/null +++ b/UA1/tareas/dev_13/tarea2 @@ -0,0 +1,52 @@ +//MAIN + +public class Main { + public static void main(String[] args) { + // Crea una instancia de la clase proyectoleer + proyectoleer pyleer = new proyectoleer(); + + // Ejecuta el método que lee y muestra la cadena + pyleer.leerYMostrarCadena(); + } +} + +//Clase que se encarga de leer una cadena de caracteres + +import java.util.Scanner; + +public class proyectoleer { + + /** + * Método principal que lee una cadena desde la entrada estándar + * hasta recibir un carácter de terminación ('*') y muestra la cadena completa. + */ + public void leerYMostrarCadena() { + Scanner scanner = new Scanner(System.in); + StringBuilder cadena = new StringBuilder(); + char caracter = ' '; + + System.out.println("Introduce caracteres. Termina con '*':"); + + // Bucle para leer caracteres hasta encontrar '*' + while (true) { + try { + // Lee el siguiente carácter de la entrada estándar + caracter = scanner.nextLine().charAt(0); + + // Verifica si es el carácter de terminación + if (caracter == '*') { + break; + } + // Añade el carácter leído a la cadena + cadena.append(caracter); + + } catch (Exception e) { + System.out.println("Error al leer el carácter. Intenta de nuevo."); + } + } + + // Muestra toda la cadena leída + System.out.println("Cadena leída: " + cadena.toString()); + scanner.close(); + } +} From daace170a43390ac8debf34cf8c22a01d760ba5a Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 16 Oct 2024 10:22:51 +0200 Subject: [PATCH 07/22] crear clase Main.java --- UA1/tareas/dev_13/Tarea 3/Main.java | 41 +++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 UA1/tareas/dev_13/Tarea 3/Main.java diff --git a/UA1/tareas/dev_13/Tarea 3/Main.java b/UA1/tareas/dev_13/Tarea 3/Main.java new file mode 100644 index 00000000..748c6d33 --- /dev/null +++ b/UA1/tareas/dev_13/Tarea 3/Main.java @@ -0,0 +1,41 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class Main { + public static void main(String[] args) { + // Asegurarse de que se pase al menos un argumento al programa Validador + if (args.length < 1) { + System.out.println("Por favor, proporciona un argumento para validar."); + return; + } + + // Construir el comando para ejecutar el programa Validador + String command = "java Validador " + args[0]; + + try { + Process process = Runtime.getRuntime().exec(command); + int exitCode = process.waitFor(); + + // Mostrar el resultado según el código de salida + switch (exitCode) { + case 1: + System.out.println("Error: El número de argumentos es menor que 1."); + break; + case 2: + System.out.println("Error: El argumento es una cadena."); + break; + case 3: + System.out.println("Error: El argumento es un número entero menor que 0."); + break; + case 0: + System.out.println("El argumento es válido."); + break; + default: + System.out.println("Código de salida desconocido: " + exitCode); + } + } catch (IOException | InterruptedException e) { + System.out.println("Error al ejecutar el programa Validador: " + e.getMessage()); + } + } +} From 19c088b26f3b86b4ad03cccaa74eae5f7a0af074 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 16 Oct 2024 10:23:41 +0200 Subject: [PATCH 08/22] Creacion del Validador.java --- UA1/tareas/dev_13/Tarea 3/Validador.java | 27 ++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 UA1/tareas/dev_13/Tarea 3/Validador.java diff --git a/UA1/tareas/dev_13/Tarea 3/Validador.java b/UA1/tareas/dev_13/Tarea 3/Validador.java new file mode 100644 index 00000000..38fa9469 --- /dev/null +++ b/UA1/tareas/dev_13/Tarea 3/Validador.java @@ -0,0 +1,27 @@ +import java.util.Scanner; + +public class Validador { + public static void main(String[] args) { + // Verificar el número de argumentos + if (args.length < 1) { + System.exit(1); + } + + // Validar el primer argumento + String argumento = args[0]; + + // Verificar si es un número entero + try { + int numero = Integer.parseInt(argumento); + if (numero < 0) { + System.exit(3); + } + } catch (NumberFormatException e) { + // Si no se puede convertir a número, es una cadena + System.exit(2); + } + + // Si no se cumplen ninguna de las condiciones anteriores + System.exit(0); + } +} From 218f4602663047e75bfd1d930514f00ef934061d Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 16 Oct 2024 17:40:04 +0200 Subject: [PATCH 09/22] Examen ua1ex1_teoria.txt --- UA1/examen/dev_13/ua1ex1_teoria.txt | 75 +++++++++++++++++++++++++++-- 1 file changed, 71 insertions(+), 4 deletions(-) diff --git a/UA1/examen/dev_13/ua1ex1_teoria.txt b/UA1/examen/dev_13/ua1ex1_teoria.txt index 2ea0d591..10726f03 100644 --- a/UA1/examen/dev_13/ua1ex1_teoria.txt +++ b/UA1/examen/dev_13/ua1ex1_teoria.txt @@ -1,16 +1,83 @@ -NOMBRE: -FECHA: +EXAMEN PSP +Día 16/10/2024 PARTE TEÓRICA -a) Definición de proceso. 1 punto. +a) Definición de proceso. Ilustra tu solución con un ejemplo. 1 punto. + +Un proceso es un programa que está en ejecución. Cuando tu ejecutas un programa el sistema operativo lo convierte en un proceso al asignarle recursos como memoria y un identificador único llamado PID. Este proceso tiene su propio estado y puede funcionar de manera independiente de otros procesos. + +Ejemplo: + +Cuando abres Chrome, se crea un proceso que ejecuta el navegador. Si abres otra ventana de Chrome, puede crearse un segundo proceso, y ambos pueden ejecutarse al mismo tiempo, compartiendo recursos pero funcionando de manera independiente. + + +b) Utilizando tus propias palabras, indica la relación entre hilos y procesos. Ilustra tu solución con un ejemplo. 3 puntos. + +La relación entre los hilos y los procesos está en que los hilos son partes más pequeñas que se ejecutan dentro de un proceso. Un proceso es un programa en ejecución con su propio espacio de memoria, mientras que los hilos dentro de ese proceso comparten los mismos recursos y pueden realizar varias tareas al mismo tiempo. + +Ejemplo: + +En una aplicación como Word, el proceso principal maneja el programa, y dentro de ese proceso, varios hilos trabajan a la vez en paralelo: uno para escribir, otro para guardar automáticamente, y otro para revisar la ortografía. Todos los hilos comparten el mismo documento lo que hace que todo funcione de una manera más fluida. + + + -b) Utilizando tus propias palabras, indica la relación entre hilos y procesos. 3 puntos. c) Utilizando tus propias palabras, indica las características de la programación concurrente y sus ámbitos de aplicación. 3 puntos. +La programación concurrente es aquella que realiza la ejecución simultánea de múltiples procesos o hilos, permitiendo así que varias tareas se puedan realizar al mismo tiempo, bien sea intercalando su ejecución o colaborando entre sí. + +Las características de la programación concurrente son las siguientes: + +Ejecución simultánea: Permite que varios hilos o procesos se ejecuten a la vez, mejorando así el uso de los recursos del sistema. + +Interacción: Los hilos o procesos pueden comunicarse entre sí, colaborando para lograr un objetivo común o compitiendo por recursos del sistema. + + +Los ámbitos de aplicación son los siguientes: + +Sistemas de control: Utilizados en la automatización industrial. + +Desarrollo de aplicaciones web: Los servidores web suelen usar la programación concurrente para manejar datos simultáneos de clientes. + +Interfaces gráficas de usuario (GUI):En aplicaciones de escritorio hace que la interfaz permanezca activa mientras se realizan tareas en segundo plano, como cargas de archivos o procesamiento de datos. + + + d) Utilizando tus propias palabras, indica las diferencias entre programación paralela y programación distribuida, sus ventajas e inconvenientes. 3 puntos. +Programación paralela: Es la ejecución simultánea de tareas en un único sistema con múltiples procesos o núcleos. El objetivo es dividir un problema en partes que puedan ser resueltas al mismo tiempo + +Programación distribuida: Es la ejecución de tareas en múltiples sistemas independientes que están interconectados a través de una red. Los componentes del sistema pueden estar físicamente separados y colaboran para completar una tarea. + +Ventajas: + +Programación paralela: + +Mejora el rendimiento al reducir el tiempo de ejecución al dividir tareas complejas. +Aprovecha al máximo los recursos del sistema al utilizar múltiples núcleos o procesadores. + +Programación distribuida: + +Permite escalar aplicaciones fácilmente agregando más sistemas a la red sin necesidad de cambiar la arquitectura del software. +Si un nodo falla, otros nodos pueden continuar operando. + +Inconvenientes: + +Programación paralela: + +La programación y gestión de procesos paralelos pueden ser difíciles, requiriendo un buen manejo de la sincronización y la comunicación entre hilos. +Requiere hardware compatible y puede no ser efectivo si el problema no se puede dividir adecuadamente. + +Programación distribuida: + +La comunicación entre nodos puede ser lenta y propensa a fallos, lo que puede afectar el rendimiento en general. +Es más complicado gestionar errores y excepciones, ya que los sistemas pueden ser heterogéneos y operar en diferentes entornos. + + Notas: El nombre del fichero .txt a entregar debe ser: examen\dev_X\ua1ex1_teoria.txt , es decir, el fichero ua1ex1_teoria.txt debe estar ubicado en tu carpeta examen\dev_X\ + +No entregues tu solución, hasta que no se indique por parte del profesorado. From 8cc2b5c804ebfac60aa0e7fc23a950ca8bbdb687 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 16 Oct 2024 18:55:06 +0200 Subject: [PATCH 10/22] Add files via upload --- UA1/examen/dev_13/ua1ex1p1.c | 44 ++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 UA1/examen/dev_13/ua1ex1p1.c diff --git a/UA1/examen/dev_13/ua1ex1p1.c b/UA1/examen/dev_13/ua1ex1p1.c new file mode 100644 index 00000000..ecf36a19 --- /dev/null +++ b/UA1/examen/dev_13/ua1ex1p1.c @@ -0,0 +1,44 @@ +#include +#include +#include +#include +#include + +// Función para mostrar la información del hijo +void mostrarInformacionHijos(int hijo_numero) { + pid_t pHijo = getpid(); // PID del hijo + pid_t pPadre = getppid(); // PID del padre + + printf("El hijo %d tiene un PID de %d y el de su PADRE es %d.\n", hijo_numero, pHijo, pPadre); +} + +int main() { + pid_t pPadre = getpid(); // PID del proceso padre + int numHijos = 3; // Numero de hijos que vamos a crear + pid_t pHijo; + + // Crear los hijos en un bucle + for (int i = 1; i <= numHijos; i++) { + pHijo = fork(); + + if (pHijo < 0) { // Control de errores + perror("Error al intentar crear el hijo"); + exit(EXIT_FAILURE); + } + + if (pHijo == 0) { // Código ejecutado por el hijo + mostrarInformacionHijos(i); + exit(EXIT_SUCCESS); // El hijo termina su ejecución + } + } + + // Esperar a que terminen todos los hijos + for (int i = 0; i < numHijos; i++) { + wait(NULL); + } + + // PID del padre antes de finalizar + printf("PID del proceso PADRE: %d\n", pPadre); + + return 0; +} From 0e0db657d4060733c9fa34a29e33c45b061aaa2f Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 16 Oct 2024 19:53:33 +0200 Subject: [PATCH 11/22] PROGRAMA HUERTO sensorMonitorizacion.java --- .../ejercicio2/sensorMonitorizacion.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java diff --git a/UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java b/UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java new file mode 100644 index 00000000..5d365732 --- /dev/null +++ b/UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java @@ -0,0 +1,25 @@ +public class sensorMonitorizacion { + public static void main(String[] args) { + + // Crearemos los hilos para cada sensor: + Thread STemperatura = new Thread(new STemperatura()); + Thread SHumedad = new Thread(new SHumedad()); + Thread SPlantasEstado = new Thread(new SPlantasEstado()); + + // Iniciamos los hilos: + STemperatura.start(); + SHumedad.start(); + SPlantasEstado.start(); + + // Esperar a que todos los hilos terminen + try { + STemperatura.join(); + SHumedad.join(); + SPlantasEstado.join(); + } + catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("La sesion de monitoreo ha terminado."); + } + } From 3f6c95eb1cd4ed3792c5c0860202cbf0c93b1725 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 16 Oct 2024 19:54:05 +0200 Subject: [PATCH 12/22] Add files via upload --- UA1/examen/dev_13/ejercicio2/SHumedad.java | 22 +++++++++++++++++++ .../dev_13/ejercicio2/SPlantasEstado.java | 22 +++++++++++++++++++ .../dev_13/ejercicio2/STemperatura.java | 22 +++++++++++++++++++ 3 files changed, 66 insertions(+) create mode 100644 UA1/examen/dev_13/ejercicio2/SHumedad.java create mode 100644 UA1/examen/dev_13/ejercicio2/SPlantasEstado.java create mode 100644 UA1/examen/dev_13/ejercicio2/STemperatura.java diff --git a/UA1/examen/dev_13/ejercicio2/SHumedad.java b/UA1/examen/dev_13/ejercicio2/SHumedad.java new file mode 100644 index 00000000..03efc2aa --- /dev/null +++ b/UA1/examen/dev_13/ejercicio2/SHumedad.java @@ -0,0 +1,22 @@ +import java.util.Random; + +public class SHumedad implements Runnable { + //Declaramos el numero de ciclos + private static final int NUM_CYCLES = 10; + private Random random = new Random(); + + @Override + public void run() { + for (int i = 0; i < NUM_CYCLES; i++) { + int value = random.nextInt(90 - 15 + 1) + 5; // Rango de humedad entre 15 y 90 + long timestamp = System.currentTimeMillis(); + System.out.println("("+ timestamp +") Humedad: " + value + "%"); + try { + Thread.sleep(random.nextInt(3000 - 1000) + 1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + System.out.println("La humedad termino su lecturas."); + } +} \ No newline at end of file diff --git a/UA1/examen/dev_13/ejercicio2/SPlantasEstado.java b/UA1/examen/dev_13/ejercicio2/SPlantasEstado.java new file mode 100644 index 00000000..fa6a8bfc --- /dev/null +++ b/UA1/examen/dev_13/ejercicio2/SPlantasEstado.java @@ -0,0 +1,22 @@ +import java.util.Random; + +public class SPlantasEstado implements Runnable { + //Declaramos el numero de ciclos + private static final int NUM_CYCLES = 10; + private Random random = new Random(); + + @Override + public void run() { + for (int i = 0; i < NUM_CYCLES; i++) { + int value = random.nextInt(10 - 1 + 1) + 1; // Estado de plantas entre 1 y 10 + long timestamp = System.currentTimeMillis(); + System.out.println("("+ timestamp +") Salud de las plantas (1-10): " + value); + try { + Thread.sleep(random.nextInt(3000 - 1000) + 1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + System.out.println("El estado de las plantas termino su lecturas."); + } +} diff --git a/UA1/examen/dev_13/ejercicio2/STemperatura.java b/UA1/examen/dev_13/ejercicio2/STemperatura.java new file mode 100644 index 00000000..d992e26f --- /dev/null +++ b/UA1/examen/dev_13/ejercicio2/STemperatura.java @@ -0,0 +1,22 @@ +import java.util.Random; + +public class STemperatura implements Runnable { + //Declaramos el numero de ciclos + private static final int NUM_CYCLES = 10; + private Random random = new Random(); + + @Override + public void run() { + for (int i = 0; i < NUM_CYCLES; i++) { + int value = random.nextInt(50 - 15 + 1) + 15; // Rango de temperatura entre 15 y 50 + long timestamp = System.currentTimeMillis(); + System.out.println("("+ timestamp +") Temperatura: " + value + "Cº"); + try { + Thread.sleep(random.nextInt(3000 - 1000) + 1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + System.out.println("La temperatura termino su lecturas."); + } +} From 74db0dafc1af66c511e530093da56270160d5cf2 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 23 Oct 2024 19:40:19 +0200 Subject: [PATCH 13/22] Cambio codigo pullrequest --- UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java b/UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java index 5d365732..15849c86 100644 --- a/UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java +++ b/UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java @@ -23,3 +23,8 @@ public static void main(String[] args) { System.out.println("La sesion de monitoreo ha terminado."); } } +//Comparando mi codigo con el proporcionado por el profesor, no eh sido capaz de encontrar ninguna mejorla la cual hacer a micodigo +//puesto a que mientras el del profesor se trara de 1 sola clase, donde se crean los hilos y se les asigna valores random +//el mio esta compuesto por 4 clases, 1 para el ejecutor de los sensres (main) y el resto para los hilos, de esta manera puedo +//manejar los valores que asignare a estos hilos, como por ejemplo al de temperatura, teniendo en cuenta que es raro que en +//mi ciudad la temperatura este por encima de los 50ºC. \ No newline at end of file From 2f5ff88dba50e6f9e8390e939eade5a09a30a3e0 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 13 Nov 2024 13:26:38 +0100 Subject: [PATCH 14/22] Primera parte tarea 2 ua2tarea1fr1.java --- UA2/tareas/dev_0/tarea_1/ua2tarea1fr1.java | 68 ++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/UA2/tareas/dev_0/tarea_1/ua2tarea1fr1.java b/UA2/tareas/dev_0/tarea_1/ua2tarea1fr1.java index e69de29b..4a0e7306 100644 --- a/UA2/tareas/dev_0/tarea_1/ua2tarea1fr1.java +++ b/UA2/tareas/dev_0/tarea_1/ua2tarea1fr1.java @@ -0,0 +1,68 @@ +class Contador +{ + private int c = 0; //iniciamos Contador + Contador (int c) { + this.c = c; + } + + public void incrementa() { + c+=1000; + } + + public int valor() { + return c; + } +} // Fin Class Contador + + +class hiloRest extends Thread +{ + private Contador contador; + + public hiloRest(String nombre, Contador c) { + setName(nombre); + contador = c; + } + + public void run() { + contador.incrementa(); + System.out.println(getName() + " - contador vale " + contador.valor()); + } +} // Fin Class HiloRestador + + +public class ua2tarea1fr1 { + public static void main(String[] args) { + + Contador cont = new Contador(0); + hiloRest hiloRest1 = new hiloRest("Hilo Restador 1", cont); + hiloRest hiloRest2 = new hiloRest("Hilo Restador 2", cont); + hiloRest hiloRest3 = new hiloRest("Hilo Restador 3", cont); + hiloRest hiloRest4 = new hiloRest("Hilo Restador 4", cont); + hiloRest hiloRest5 = new hiloRest("Hilo Restador 5", cont); + + hiloRest1.start(); + + hiloRest2.start(); + + hiloRest3.start(); + + hiloRest4.start(); + + hiloRest5.start(); + + try { + hiloRest1.join(); + hiloRest2.join(); + hiloRest3.join(); + hiloRest4.join(); + hiloRest5.join(); + } + catch (InterruptedException e) + { + // Nothing to do here ... + } + System.out.println("Finaliza la ejecución de los hilos"); + System.out.println("Valor Final del Contador: " + cont.valor()); + } +} From 3fdc8ab5d04e14b6202923f03d043222761cc09d Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 13 Nov 2024 13:32:01 +0100 Subject: [PATCH 15/22] Edicion tarea 1 apartado 2 ua2tarea1fr2.java --- UA2/tareas/dev_0/tarea_1/ua2tarea1fr2.java | 63 +++++++++++++++++++++- 1 file changed, 62 insertions(+), 1 deletion(-) diff --git a/UA2/tareas/dev_0/tarea_1/ua2tarea1fr2.java b/UA2/tareas/dev_0/tarea_1/ua2tarea1fr2.java index 2f3163e2..219538fd 100644 --- a/UA2/tareas/dev_0/tarea_1/ua2tarea1fr2.java +++ b/UA2/tareas/dev_0/tarea_1/ua2tarea1fr2.java @@ -1,5 +1,66 @@ -package UA2.tareas.dev_0.tarea_1; +class Contador +{ + private int c = 0; + Contador (int c) { + this.c = c; + } + + public synchronized void incrementa() { + c+=1000; + } + + public int valor() { + return c; + } +} + + +class hiloRest extends Thread +{ + + private Contador contador; + + public hiloRest(String nombre, Contador c) { + setName(nombre); + contador = c; + } + + public void run() { + contador.incrementa(); + System.out.println(getName() + " - contador vale " + contador.valor()); + } +} + public class ua2tarea1fr2 { + public static void main(String[] args) { + + Contador cont = new Contador(0); + hiloRest hiloRest1 = new hiloRest("Hilo 1", cont); + hiloRest hiloRest2 = new hiloRest("Hilo 2", cont); + hiloRest hiloRest3 = new hiloRest("Hilo 3", cont); + hiloRest hiloRest4 = new hiloRest("Hilo 4", cont); + hiloRest hiloRest5 = new hiloRest("Hilo 5", cont); + + hiloRest1.start(); + hiloRest2.start(); + hiloRest3.start(); + hiloRest4.start(); + hiloRest5.start(); + + try { + hiloRest1.join(); + hiloRest2.join(); + hiloRest3.join(); + hiloRest4.join(); + hiloRest5.join(); + } + catch (InterruptedException e) + { + // Nothing to do here ... + } + System.out.println("Finaliza la ejecución de los hilos"); + System.out.println("Valor Final del Contador: " + cont.valor()); + } } From 6f0b19898c70cd950cb3be0217e0e9f30100f6eb Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 13 Nov 2024 13:34:54 +0100 Subject: [PATCH 16/22] Creacion del codigo ua2tarea1fr2runnable.java --- .../dev_0/tarea_1/ua2tarea1fr2runnable.java | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 UA2/tareas/dev_0/tarea_1/ua2tarea1fr2runnable.java diff --git a/UA2/tareas/dev_0/tarea_1/ua2tarea1fr2runnable.java b/UA2/tareas/dev_0/tarea_1/ua2tarea1fr2runnable.java new file mode 100644 index 00000000..4898c3b0 --- /dev/null +++ b/UA2/tareas/dev_0/tarea_1/ua2tarea1fr2runnable.java @@ -0,0 +1,65 @@ +class Contador +{ + private int c = 0; + Contador (int c) { + this.c = c; + } + + public synchronized void incrementa() { + c+=1000; + } + + public int valor() { + return c; + } +} + + +class hiloRest implements Runnable +{ + private String nombre; + private Contador contador; + + public hiloRest(String nombre, Contador c) { + this.nombre=nombre; + contador = c; + } + + public void run() { + contador.incrementa(); + System.out.println(nombre + " - contador vale " + contador.valor()); + } +} + + +public class ua2tarea1fr2runnable { + public static void main(String[] args) { + + Contador cont = new Contador(0); + Thread hiloRest1 = new Thread(new hiloRest("Hilo 1", cont)); + Thread hiloRest2 = new Thread(new hiloRest("Hilo 2", cont)); + Thread hiloRest3 = new Thread(new hiloRest("Hilo 3", cont)); + Thread hiloRest4 = new Thread(new hiloRest("Hilo 4", cont)); + Thread hiloRest5 = new Thread(new hiloRest("Hilo 5", cont)); + + hiloRest1.start(); + hiloRest2.start(); + hiloRest3.start(); + hiloRest4.start(); + hiloRest5.start(); + + try { + hiloRest1.join(); + hiloRest2.join(); + hiloRest3.join(); + hiloRest4.join(); + hiloRest5.join(); + } + catch (InterruptedException e) + { + // Nothing to do here ... + } + System.out.println("Finaliza la ejecución de los hilos"); + System.out.println("Valor Final del Contador: " + cont.valor()); + } +} From 3f07779942e7b768b0d0be3be282029c036a1c0c Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Sun, 17 Nov 2024 22:13:06 +0100 Subject: [PATCH 17/22] Create CuentaCorriente.java --- UA2/tareas/dev_0/tarea_2/CuentaCorriente.java | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 UA2/tareas/dev_0/tarea_2/CuentaCorriente.java diff --git a/UA2/tareas/dev_0/tarea_2/CuentaCorriente.java b/UA2/tareas/dev_0/tarea_2/CuentaCorriente.java new file mode 100644 index 00000000..0d2e681d --- /dev/null +++ b/UA2/tareas/dev_0/tarea_2/CuentaCorriente.java @@ -0,0 +1,38 @@ +import java.util.Random; + +public class CuentaCorriente { + private double saldo; + + public CuentaCorriente(double saldoInicial) { + this.saldo = saldoInicial; + } + + public synchronized double getSaldo() { + sleepRandom(); + return saldo; + } + + public synchronized void setSaldo(double saldo) { + sleepRandom(); + this.saldo = saldo; + } + + public synchronized void añadirSaldo(double cantidad, String nombreHilo) { + System.out.println(nombreHilo + " va a añadir: " + cantidad); + System.out.println("Saldo antes del ingreso: " + saldo); + sleepRandom(); + saldo += cantidad; + System.out.println("Saldo después del ingreso: " + saldo); + } + + private void sleepRandom() { + try { + Random random = new Random(); + int tiempoEspera = 250 + random.nextInt(1751); + Thread.sleep(tiempoEspera); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + System.out.println("Error en sleepRandom: " + e.getMessage()); + } + } +} From 5b83ac757a53f03aa3f3f199fa7cd7118ee0832d Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Sun, 17 Nov 2024 22:15:24 +0100 Subject: [PATCH 18/22] Create HiloCuentaCorriente.java --- .../dev_0/tarea_2/HiloCuentaCorriente.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 UA2/tareas/dev_0/tarea_2/HiloCuentaCorriente.java diff --git a/UA2/tareas/dev_0/tarea_2/HiloCuentaCorriente.java b/UA2/tareas/dev_0/tarea_2/HiloCuentaCorriente.java new file mode 100644 index 00000000..56e4e522 --- /dev/null +++ b/UA2/tareas/dev_0/tarea_2/HiloCuentaCorriente.java @@ -0,0 +1,17 @@ +public class HiloCuentaCorriente extends Thread { + private CuentaCorriente cuenta; + private double cantidad; + private String nombre; + + public HiloCuentaCorriente(CuentaCorriente cuenta, double cantidad, String nombre) { + this.cuenta = cuenta; + this.cantidad = cantidad; + this.nombre = nombre; + this.setName(nombre); + } + + @Override + public void run() { + cuenta.añadirSaldo(cantidad, nombre); + } +} From 5e42e4af1557cedd741a9c3cf6e466a1fe7a14d5 Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Sun, 17 Nov 2024 22:15:45 +0100 Subject: [PATCH 19/22] Create Main.java --- UA2/tareas/dev_0/tarea_2/Main.java | 56 ++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 UA2/tareas/dev_0/tarea_2/Main.java diff --git a/UA2/tareas/dev_0/tarea_2/Main.java b/UA2/tareas/dev_0/tarea_2/Main.java new file mode 100644 index 00000000..f16fe6c7 --- /dev/null +++ b/UA2/tareas/dev_0/tarea_2/Main.java @@ -0,0 +1,56 @@ +public class Main { + public static void main(String[] args) { + // Saldo inicial + double saldoInicial = 1000.0; + CuentaCorriente cuenta = new CuentaCorriente(saldoInicial); + System.out.println("Saldo inicial: " + cuenta.getSaldo()); + System.out.println("----------------------------------------"); + + // Crear y lanzar hilos + HiloCuentaCorriente hilo1 = new HiloCuentaCorriente(cuenta, 500, "Hilo1"); + HiloCuentaCorriente hilo2 = new HiloCuentaCorriente(cuenta, 300, "Hilo2"); + HiloCuentaCorriente hilo3 = new HiloCuentaCorriente(cuenta, 200, "Hilo3"); + + hilo1.start(); + hilo2.start(); + hilo3.start(); + + // Esperar a que los hilos terminen + try { + hilo1.join(); + hilo2.join(); + hilo3.join(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + System.out.println("Error al esperar los hilos: " + e.getMessage()); + } + + // Mostrar saldo final + System.out.println("Saldo final (con synchronized): " + cuenta.getSaldo()); + System.out.println("----------------------------------------"); + + // Repetir sin synchronized + System.out.println("Ejecutando sin synchronized..."); + CuentaCorriente cuentaNoSync = new CuentaCorriente(saldoInicial); + System.out.println("Saldo inicial: " + cuentaNoSync.getSaldo()); + + HiloCuentaCorriente hilo4 = new HiloCuentaCorriente(cuentaNoSync, 500, "Hilo4"); + HiloCuentaCorriente hilo5 = new HiloCuentaCorriente(cuentaNoSync, 300, "Hilo5"); + HiloCuentaCorriente hilo6 = new HiloCuentaCorriente(cuentaNoSync, 200, "Hilo6"); + + hilo4.start(); + hilo5.start(); + hilo6.start(); + + try { + hilo4.join(); + hilo5.join(); + hilo6.join(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + System.out.println("Error al esperar los hilos: " + e.getMessage()); + } + + System.out.println("Saldo final (sin synchronized): " + cuentaNoSync.getSaldo()); + } +} From c54fa871ae5c4fb4c82ae2c66887d9b69c55dfcc Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 11 Dec 2024 17:33:22 +0100 Subject: [PATCH 20/22] Primera parte del examen ua2ex1.txt --- UA2/examen/ejercicio1/dev_13/ua2ex1.txt | 76 +++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 UA2/examen/ejercicio1/dev_13/ua2ex1.txt diff --git a/UA2/examen/ejercicio1/dev_13/ua2ex1.txt b/UA2/examen/ejercicio1/dev_13/ua2ex1.txt new file mode 100644 index 00000000..a4ce49c3 --- /dev/null +++ b/UA2/examen/ejercicio1/dev_13/ua2ex1.txt @@ -0,0 +1,76 @@ +Conceptos básicos sobre hilos (1 punto): + a) Define qué es un hilo en Java y cómo se relaciona con la multitarea. + + Un hilo en java es un subproceso, es decir, una forma de ejecutar varios procesos de manera concurrente. + En Java, los hilos se utilizan para realizar tareas simultáneas, como por ejemplo, ejecutar un proceso en segundo plano mientras el programa principal sigue ejecutándose. + + Se relaciona con la multitarea ya que permite que un programa realice varias tareas al mismo tiempo, lo que hace mejor la eficiencia y la capacidad de respuesta + de la aplicación. + + b) Menciona dos diferencias entre la interfaz Runnable y la clase Thread. + + 1. La interfaz Runnable es una interfaz funcional que se utiliza para definir una tarea que se puede ejecutar en un hilo, mientras que la clase Thread es una clase que + se utiliza para crear y controlar hilos en Java. + + 2. Una clase puede implementar la interfaz Runnable y extender otra clase, mientras que solo puede extender de una unica clase en Java. + +Sincronización (1 punto): + a) Explica qué es la sincronización de hilos y por qué es necesaria en Java. + + La sincronizacion de los hilos es el proceso mediante el cual se controla el acceso a los recursos compartidos por varios hilos para evitar problemas de concurrencia, como condiciones de carrera + y bloqueos mutuos. Es necesaria en Java para garantizar que los hilos no interfieran entre ellos al acceder a los mismo recursos al mismo tiempo. + + b) ¿Qué problemas pueden surgir si no se sincronizan adecuadamente los hilos? + + Si no se sincronizan de manera correcta los hilos, pueden surgir problemas de concurrencia, como condiciones de carrera, bloqueos mutuos y corrupción de datos. Esto puede + provocar que los hilos accedan a los mismo recursos al mismo tiempo, lo que puede dar lugar a resultados inesperados y errores en la aplicación. + +Estados de un hilo (1 punto): + a) Nombra y describe brevemente los principales estados de un hilo en su ciclo de vida. + + Principales estados de un hilo en Java: + + 1. Nuevo: El hilo ha sido creado pero aun no ha sido identificado. + 2. Listo: El hilo esta listo para ser usado pero aun no ha sido ejecutado. + 3. En ejecución: El hilo esta siendo ejecutado por el planificador de hilos. + 4. Bloqueado: El hilo esta esperando para acceder a un recurso compartido. + 5. Terminado: El hilo ha completado su ejecucion y ha terminado. + + b) ¿Qué método en Java se utiliza para pausar un hilo por un tiempo específico? + + El metodo usado para pausar un hilo por un tiempo especifico en Java es el metodo thread.sleep();. + +Bloques sincronizados y monitores (1 punto): + a) ¿Qué es un monitor en Java? + + Un monitor en Java es un mecanismo que se utiliza para asegurar el acceso exclusivo a un recurso compartido por varios hilos. + + b) Explica cómo se utiliza el bloque synchronized para garantizar acceso exclusivo a un recurso. + + El bloque synchronized se utiliza para asegurar el acceso exclusivo a un recurso compartido por varios hilos. Para ello se utiliza la palabra clave synchronized seguida + de un objeto de bloqueo, que puede ser un objeto o una clase. Cuando un hilo entra en un bloque synchronized adquiere un bloqueo sobre el objeto al que ningun otro hilo + puede acceder hasta que el hilo que lo tiene lo libere. + + +Métodos avanzados en hilos (1 punto): + a) ¿Qué diferencia existe entre los métodos wait(), notify(), y notifyAll() en Java? + + wait(): Se utiliza para hacer que un hilo espere hasta que otro hilo notifique que se ha producido un cambio en el recurso compartido. + notify(): Se utiliza para notificar a un hilo en espera que se ha producido un cambio en el recurso compartido. + notifiAll(): Se utiliza para notificar a todos los hilos en espera que se ha producido un cambio en el recurso compartido. + + b) Explica un caso práctico donde utilizarías estos métodos para resolver un problema de concurrencia. + + Usar wait(): + Tenemos un hilo que produce un recurso comparido y otro que se encarga de consumirlo, si el hilo consumidor intenta consumir el recurso antes de que el hilo productor + lo haya producido, podemos aplicar un wait() al hilo consumidor para que espere hasta que el hilo productor haya producido el recurso. + + Usar notify(): + Tenemos varios hilos, que comparten un mismo recurso entre si, si un hilo modifica el recurso y quiere notificar a los demas hilos que se ha producido un cmabio, podemos + aplicar un notify(): al hilo modificador para que notifique a los demas hilos que estan en espera que modifico el recuros. + + Usar notifyAll(): + Tenemos varios hilos, compartiendo un mismo recurso, si un hilo modifica el recurso y quiere notificar a todos los demas hilos, podemos aplicar un notifyAll() al hilo + modificador para que notifique a todos los hilos que modifico el recurso. + +Toda la implementación debe estar en un único fichero .txt, nombrado como: UA2/examen/ejercicio1/dev_X/ua2ex1.txt From 2ccc8e703ab016c2f51e9b084dd8b0acdff28d4c Mon Sep 17 00:00:00 2001 From: AlexJimenezRoj2005 <162628910+AlexJimenezRoj2005@users.noreply.github.com> Date: Wed, 11 Dec 2024 19:31:59 +0100 Subject: [PATCH 21/22] Parte practica ua2ex2.java --- UA2/examen/ejercicio2/dev_13/ua2ex2.java | 188 +++++++++++++++++++++++ 1 file changed, 188 insertions(+) create mode 100644 UA2/examen/ejercicio2/dev_13/ua2ex2.java diff --git a/UA2/examen/ejercicio2/dev_13/ua2ex2.java b/UA2/examen/ejercicio2/dev_13/ua2ex2.java new file mode 100644 index 00000000..db953494 --- /dev/null +++ b/UA2/examen/ejercicio2/dev_13/ua2ex2.java @@ -0,0 +1,188 @@ +/** + * Clase principal que ejecuta el productor y el consumidor. + */ +public class Main { + /** + * Método principal donde se inicializan los hilos productor y consumidor. + * + * @param args Argumentos de la línea de comandos (no utilizados). + */ + public static void main(String[] args) { + // Crear un buffer con capacidad para 10 caracteres. + Buffer buffer = new Buffer(10); + + // Crear el hilo productor y el hilo consumidor. + Productor productor = new Productor(buffer); + Consumidor consumidor = new Consumidor(buffer); + + // Iniciar ambos hilos. + productor.start(); + consumidor.start(); + } +} + +/** + * Clase Buffer que simula una zona de memoria compartida entre el productor y el consumidor. + * + * El buffer tiene una capacidad fija y permite la producción y consumo de caracteres de manera sincronizada. + */ +public class Buffer { + private char[] buffer; /**< Buffer que almacena los caracteres producidos. */ + private int capacidad; /**< Capacidad máxima del buffer. */ + private int indiceEscritura; /**< Índice donde se escribe el siguiente carácter. */ + private int indiceLectura; /**< Índice desde donde se lee el siguiente carácter. */ + + /** + * Constructor de la clase Buffer. + * + * @param capacidad La capacidad máxima del buffer. + */ + public Buffer(int capacidad) { + this.capacidad = capacidad; + this.buffer = new char[capacidad]; + this.indiceEscritura = 0; + this.indiceLectura = 0; + } + + /** + * Método para producir un carácter y almacenarlo en el buffer. + * Si el buffer está lleno, el hilo productor espera hasta que haya espacio. + * + * @param c El carácter a producir. + */ + public synchronized void producir(char c) { + // Si el buffer está lleno, espera hasta que haya espacio. + while (indiceEscritura == capacidad) { + try { + wait(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + // Añadir el carácter al buffer y actualizar el índice de escritura. + buffer[indiceEscritura] = c; + indiceEscritura++; + + // Notificar a todos los hilos esperando (en este caso el consumidor). + notifyAll(); + + // Mostrar el estado del buffer después de producir un carácter. + mostrarEstado(); + } + + /** + * Método para consumir un carácter del buffer. + * Si el buffer está vacío, el hilo consumidor espera hasta que haya algo que consumir. + * + * @return El carácter consumido. + */ + public synchronized char consumir() { + // Si el buffer está vacío, espera hasta que haya datos. + while (indiceLectura == indiceEscritura) { + try { + wait(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + // Obtener el carácter del buffer y actualizar el índice de lectura. + char c = buffer[indiceLectura]; + indiceLectura++; + + // Notificar a todos los hilos esperando (en este caso el productor). + notifyAll(); + + // Mostrar el estado del buffer después de consumir un carácter. + mostrarEstado(); + + return c; + } + + /** + * Método para mostrar el estado del buffer (cantidad de elementos en el buffer). + */ + private void mostrarEstado() { + System.out.println("Estado del buffer: " + (indiceEscritura - indiceLectura) + " elementos en el buffer."); + } +} + +/** + * Clase Productor que simula un hilo productor que agrega caracteres al buffer. + */ +public class Productor extends Thread { + private Buffer buffer; /**< Buffer compartido donde el productor añade los caracteres. */ + + /** + * Constructor de la clase Productor. + * + * @param buffer El buffer compartido donde se agregarán los caracteres. + */ + public Productor(Buffer buffer){ + this.buffer = buffer; + } + + /** + * Método que ejecuta el hilo productor. + * En cada iteración produce un carácter aleatorio y lo agrega al buffer. + * Luego, el hilo duerme un tiempo aleatorio entre 300 y 500 ms. + */ + @Override + public void run() { + for (int i = 0; i < 10; i++) { // Limitar a 10 caracteres producidos para simular fin. + // Generar un carácter aleatorio. + char c = (char) (Math.random() * 26 + 'A'); + System.out.println("Se ha producido el caracter: " + c); + + // Producir el carácter y agregarlo al buffer. + buffer.producir(c); + + // Hacer que el hilo duerma entre 300 y 500 ms para simular el tiempo de producción. + try { + Thread.sleep((int) (Math.random() * 200 + 300)); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + System.out.println("El productor ha terminado de producir."); + } +} + +/** + * Clase Consumidor que simula un hilo consumidor que extrae caracteres del buffer. + */ +public class Consumidor extends Thread { + private Buffer buffer; /**< Buffer compartido desde el cual el consumidor consume los caracteres. */ + + /** + * Constructor de la clase Consumidor. + * + * @param buffer El buffer compartido desde el cual se consumirán los caracteres. + */ + public Consumidor(Buffer buffer) { + this.buffer = buffer; + } + + /** + * Método que ejecuta el hilo consumidor. + * En cada iteración consume un carácter del buffer y lo imprime. + * Luego, el hilo duerme un tiempo aleatorio entre 700 y 1000 ms. + */ + @Override + public void run() { + for (int i = 0; i < 10; i++) { // Limitar a 10 caracteres consumidos para simular fin. + // Consumir un carácter del buffer. + char c = buffer.consumir(); + System.out.println("Se ha consumido el caracter: " + c); + + // Hacer que el hilo duerma entre 700 y 1000 ms para simular el tiempo de consumo. + try { + Thread.sleep((int) (Math.random() * 300 + 700)); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + System.out.println("El consumidor ha terminado de consumir."); + } +} From d953e70924612b47a14e23aa9b0214c48011c2af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20David=20Vela=20Castro?= Date: Thu, 12 Dec 2024 14:54:56 +0100 Subject: [PATCH 22/22] Update ua2ex2.java --- UA2/examen/ejercicio2/dev_13/ua2ex2.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/UA2/examen/ejercicio2/dev_13/ua2ex2.java b/UA2/examen/ejercicio2/dev_13/ua2ex2.java index db953494..595908c9 100644 --- a/UA2/examen/ejercicio2/dev_13/ua2ex2.java +++ b/UA2/examen/ejercicio2/dev_13/ua2ex2.java @@ -1,3 +1,27 @@ +/** +Feedback JD: 12/12/2024 + +Sincronización y Bloqueo: +La lógica de sincronización (wait y notifyAll) está bien implementada y evita condiciones de carrera. +Podrías usar una estructura como ArrayBlockingQueue para simplificar el código de sincronización. + +Estado del Buffer: +Mostrar el estado del buffer en cada operación es excelente para visualizar el flujo, pero podrías formatearlo mejor o incluir índices de lectura/escritura para más claridad. + +Control de Iteraciones: +Limitar las iteraciones de productor y consumidor es correcto para este ejemplo. Considera hacer configurable el número de elementos. + +Nombres Descriptivos: +Los nombres de clases y métodos son claros. Buen uso de comentarios para describir el propósito. +Rendimiento: + +Los tiempos de espera (Thread.sleep) son adecuados para simular retrasos, pero en un entorno real podría eliminarse o ajustarse según los requisitos. + +En general, ¡muy buen trabajo! Muy bien Alejandro. + + +**/ + /** * Clase principal que ejecuta el productor y el consumidor. */