Cambio codigo pullrequest

UA1/alex_jimenezR/readme.dx

@@ -0,0 +1 @@
+

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.");
+    }
+}

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.");
+    }
+}

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.");
+    }
+}

UA1/examen/dev_13/ejercicio2/sensorMonitorizacion.java

@@ -0,0 +1,30 @@
+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.");
+        }
+    }
+//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.

UA1/examen/dev_13/ua1ex1_teoria.txt

@@ -0,0 +1,83 @@
+EXAMEN PSP
+Día 16/10/2024
+
+PARTE TEÓRICA
+
+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.
+
+
+
+
+
+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.

UA1/examen/dev_13/ua1ex1p1.c

@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+// 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;
+}

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());
+        }
+    }
+}

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);
+    }
+}

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();
+    }
+}