pull request

UA1/examen/dev_3/ua1ex1ep2.java

@@ -1,34 +1,40 @@
-public class Main {
+public class ua1ex1ep2 {
     public static void main(String[] args) {
         System.out.println("Sensores");
-        Thread sensorTemperatura = new Thread(new Sensor("Sensor de Temperatura"));
-        Thread sensorHumedad =  new Thread(new Sensor("Sensor de Humedad"));
-        Thread sensorEstadoDePlantas=  new Thread(new Hilo3());
-        sensorTemperatura .start();
-        sensorHumedad.start();
-        sensorEstadoDePlantas.start();
+        Thread hilo1 = new Thread(new Hilo1());
+        Thread hilo2 =  new Thread(new Hilo2());
+        Thread hilo3=  new Thread(new Hilo3());
+        hilo1.start();
+        hilo2.start();
+        hilo3.start();
     }
 }
-// he implementado el ejemplo que nos has puesto en el sensor 1 y 2.
-class Sensor implements Runnable{
-    private String nombreSensor;
 
-    public  Sensor(String nombreSensor){
-        this.nombreSensor = nombreSensor;
-    }
+class  Hilo1 implements  Runnable{
+
     @Override
-    public void  run(){
+    public void run() {
         for (int i = 0; i < 10; i++) {
-            System.out.println(nombreSensor+" -Checkeo "+i+" : "+Math.random()*100);
+                System.out.println("En el check " + (i + 1) + " del sensor de la temperatura,  la temperatura es : "+ Math.random()*41 );
+            }
+        System.out.println("Sensor del estado de las plantas ha completado sus 10 ciclos de lectura.");
+    }
+}
 
+class  Hilo2 implements  Runnable{
+
+    @Override
+    public void run() {
+        for (int i = 0; i < 10; i++) {
+                System.out.println("En el check " + (i + 1) + " del sensor de las plantas,  la humedad es : "+ Math.random()*101 );
+
         }
-        System.out.println(nombreSensor + " ha completado sus 10 ciclos de lectura.");
+        System.out.println("Sensor de la humedad ha completado sus 10 ciclos de lectura.");
     }
 }
 
 
-// lo he dejado igual que lo tenia antes ya que no me gusta catalogar el estado de las plantas del 1 al 100
-// y creo que la forma que lo he hecho es bastante correcta.
+
 class  Hilo3 implements  Runnable{
 
     @Override
@@ -44,4 +50,4 @@ public void run() {
         }
         System.out.println("Sensor del estado de las plantas ha completado sus 10 ciclos de lectura.");
     }
-}
+}

UA2/examen/ejercicio1/dev_3/ua2ex1.txt

@@ -0,0 +1,61 @@
+Pablo Alcalá-Zamora Bermúdez
+
+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 son procesos que nos permiten gestionar varias tareas a la vez.
+Podemos relacionarlo con la multitarea ya que los hilos nos permiten ejecutar varias tareas o procesos al mismo tiempo aunque no esten relacionados entre si.
+b) Menciona dos diferencias entre la interfaz Runnable y la clase Thread.
+1.La forma de iniciarlas, por ejemplo , Thread seria: 
+Thread thread = new Thread()
+thread.start()
+y la de Runnable para empezar el hilo  es diferente.
+
+2.Tambien Runnable es uan interfaz que nos fuerza a usar la funcion "run" dentro de su clase cosa que Thread no.
+
+Sincronización (1 punto):
+a) Explica qué es la sincronización de hilos y por qué es necesaria en Java.
+La sincronizacion Es una herramiento que nos permite establecer orden mediante la gestion de los hilos para evitar que algunos hilos terminen antes que otros.
+Es necesaria la sincronizacion ya que nos ayuda a evitar errores , hilos zombie y en caso de que sea necesario para controlar las acciones de los hilos.
+b) ¿Qué problemas pueden surgir si no se sincronizan adecuadamente los hilos?
+Si por ejemplo necesitaramos que un hilo vaya siempre antes que otros si no los sincronizamos este podria ejecutarse despues de otros hilos lo que derivaria en errores.
+
+Estados de un hilo (1 punto):
+a) Nombra y describe brevemente los principales estados de un hilo en su ciclo de vida.
+new:
+Se acaba de crear el hilo
+Runnable:
+se empieza a ejecutar.
+Blocked:
+el hilo esta suspendido
+Dead: 
+El hilo ha terminado el proceso
+b) ¿Qué método en Java se utiliza para pausar un hilo por un tiempo específico?
+Dependiendo de a que nos refiramos con un tiempo especifico es un metodo u otro
+
+si nos referimos a tiempo exacto , es decir, segundos o minutos entonces hablamos de sleep el cual nos permite parar el hilo el tiempo que nosotros queramos.
+
+Si es hasta que se complete una accion es wait y lo volveriamos a activar cuando quisieramos reanudarlo con notify
+
+
+Bloques sincronizados y monitores (1 punto):
+a) ¿Qué es un monitor en Java?
+b) Explica cómo se utiliza el bloque synchronized para garantizar acceso exclusivo a un recurso.
+usando la funcion Public sinchronyzed void() e introduciendo dentro la variable que queramos sincronizar , esto nos permite que en caso de que estemos en una parte del codigo critica
+y queremos que solo un hilo a la vez use la variable se puede hacer esto.
+
+
+Métodos avanzados en hilos (1 punto):
+a) ¿Qué diferencia existe entre los métodos wait(), notify(), y notifyAll() en Java?
+wait()es el metodo que nos permite pausar un hilo de forma ilimitada, notify()es el metodo que nos permite reanudar ese mismo hilo y en el caso de
+que haya dos o mas hilos suspendidos con wait el notifyAll despierta a todos los hilos.
+b) Explica un caso práctico donde utilizarías estos métodos para resolver un problema de concurrencia.
+Si por ejemplo tenemos un hilo justo al principio de nuestro programa(por necesidades de este) 
+pero no queremos que termine hasta que los otros hayan terminado podemos pausarlo y despertarlo una vez haya terminado el proceso o el programa.
+
+Toda la implementación debe estar en un único fichero Java, nombrado como: UA2/examen/ejercicio1/dev_X/ua2ex1.txt
+
+
+
+
+
+

UA2/examen/ejercicio2/dev_3/ua2ex1.java

@@ -0,0 +1,108 @@
+/**
+Puntos fuertes:
+El código está bien estructurado y es fácil de entender.
+El uso de sincronización (synchronized, wait(), notifyAll()) es correcto y asegura que no haya condiciones de carrera.
+La lógica del buffer circular es adecuada y correctamente implementada.
+La separación clara de responsabilidades en las clases Productor, Consumidor y Buffer hace que el código sea modular y fácil de mantener.
+
+Áreas de mejora:
+El uso de notifyAll() es innecesario y puede ser menos eficiente que notify() en este contexto, ya que solo hay un productor y un consumidor que necesitan ser notificados, no todos.
+Los tiempos de espera de Thread.sleep() son fijos. Utilizar un rango aleatorio dentro de un intervalo haría que el comportamiento fuera más dinámico y realista, simulando mejor un entorno de producción/consumo variable.
+Aunque se manejan correctamente las excepciones, sería recomendable mejorar el manejo de la interrupción de hilos, específicamente asegurándose de que Thread.currentThread().interrupt() se llame cuando sea necesario después de la captura de una excepción InterruptedException.
+
+Conclusión: El código es sólido y cumple bien con la tarea. Sin embargo, hay algunos detalles que pueden mejorarse para optimizar el rendimiento y la simulación. La calificación refleja un buen trabajo, pero con espacio para algunos ajustes que aumenten la eficiencia y flexibilidad del código.
+**/
+
+class Buffer {
+    private final char[] buffer;
+    private final int capacidad;
+    private int indiceEscritura = 0;
+    private int indiceLectura = 0;
+    private int elementosActuales = 0;
+
+    public Buffer(int capacidad) {
+        this.capacidad = capacidad;
+        this.buffer = new char[capacidad];
+    }
+
+
+    public synchronized void producir(char c) throws InterruptedException {
+        while (elementosActuales == capacidad) {
+            wait();
+        }
+
+
+        buffer[indiceEscritura] = c;
+        indiceEscritura = (indiceEscritura + 1) % capacidad;
+        elementosActuales++;
+        notifyAll();
+    }
+
+    public synchronized char consumir() throws InterruptedException {
+        while (elementosActuales == 0) {
+            wait();
+        }
+
+        char c = buffer[indiceLectura];
+        indiceLectura = (indiceLectura + 1) % capacidad;
+        elementosActuales--;
+        notifyAll();
+        return c;
+    }
+}
+
+class Consumidor extends Thread {
+    private final Buffer buffer;
+
+    public Consumidor(Buffer buffer) {
+        this.buffer = buffer;
+    }
+
+    @Override
+    public void run() {
+        try {
+            while (true) {
+                char c = buffer.consumir();
+                System.out.println("Consumiendo: " + c);
+                Thread.sleep(700);
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+}
+
+class Productor extends Thread {
+    private final Buffer buffer;
+
+    public Productor(Buffer buffer) {
+        this.buffer = buffer;
+    }
+
+    @Override
+    public void run() {
+        try {
+            while (true) {
+                char c = (char) (Math.random() * 26 + 'A');
+                System.out.println("Produciendo: " + c);
+                buffer.producir(c);
+                Thread.sleep( 500);
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+}
+
+public class ua2ex1 {
+    public static void main(String[] args) {
+
+        Buffer buffer = new Buffer(10);
+        Productor productor = new Productor(buffer);
+        Consumidor consumidor = new Consumidor(buffer);
+
+        productor.start();
+        consumidor.start();
+    }
+}
+

UA2/tareas/dev_3/tarea_1/ua2tarea1fr1.java

@@ -0,0 +1,6 @@
+public class ua2tarea1fr1 {
+    public static void main(String[] args) {
+        Thread hiloOrigin= new Thread(new ua2tarea1fr2runnable());
+        hiloOrigin.start();
+    }
+}

UA2/tareas/dev_3/tarea_1/ua2tarea1fr2.java

@@ -0,0 +1,8 @@
+public class ua2tarea1fr2 {
+    public static void main(String[] args) {
+        // La principal diferencia entre este ejercicio y el anterior es el hecho de mantener un control sobre los hilos
+        // para que la variable se incremente de forma organizada
+        Thread hiloOrigin= new Thread(new ua2tarea1fr2runnable());
+        hiloOrigin.start();
+    }
+}

UA2/tareas/dev_3/tarea_1/ua2tarea1fr2runnable.java

@@ -0,0 +1,87 @@
+public class ua2tarea1fr2runnable implements Runnable {
+    //introducimos la variable contador
+    int contador=0;
+
+    @Override
+    public void run() {
+        //declaramos los hilos
+        Thread hilo1 = new Thread(new Hilo());
+        Thread hilo2 = new Thread(new Hilo2());
+        Thread hilo3 = new Thread(new Hilo3());
+        Thread hilo4 = new Thread(new Hilo4());
+        Thread hilo5 = new Thread(new Hilo5());
+//inicializo los hilos con un join para que los otros hilos no empiezen hasta que uno termine.
+//aqui se puede apreciar el principal cambio con respecto al anterior ya que en el primero no ponemos un control.
+        hilo1.start();
+        try {
+            hilo1.join();
+        } catch (InterruptedException ie) {
+            ie.printStackTrace();
+        }
+        hilo2.start();
+        try {
+            hilo2.join();
+        } catch (InterruptedException ie) {
+            ie.printStackTrace();
+        }
+        hilo3.start();
+        try {
+            hilo3.join();
+        } catch (InterruptedException ie) {
+            ie.printStackTrace();
+        }
+        hilo4.start();
+        try {
+            hilo4.join();
+        } catch (InterruptedException ie) {
+            ie.printStackTrace();
+        }
+        hilo5.start();
+        try {
+            hilo5.join();
+        } catch (InterruptedException ie) {
+            ie.printStackTrace();
+        }
+    }
+
+//creamos cinco hilos que incrementa cada uno la variable contador
+    class Hilo extends Thread {
+        @Override
+        public void run() {
+            contador+=1000;
+            System.out.println(contador);
+        }
+    }
+
+    class Hilo2 extends Thread {
+        @Override
+        public void run() {
+            contador+=1000;
+            System.out.println(contador);
+        }
+    }
+
+    class Hilo3 extends Thread {
+        @Override
+        public void run() {
+            contador+=1000;
+            System.out.println(contador);
+        }
+    }
+
+    class Hilo4 extends Thread {
+        @Override
+        public void run() {
+            contador+=1000;
+            System.out.println(contador);
+        }
+    }
+
+    class Hilo5 extends Thread {
+        @Override
+        public void run() {
+            contador+=1000;
+            System.out.println(contador);
+        }
+    }
+}