Subida Mejora Examen Java

UA1/examen/dev_17/ejercicio2/Estado.java

@@ -0,0 +1,24 @@
+public class Estado extends Thread{
+    public Estado() {
+
+    }
+
+    public void run() {
+
+        for (int i = 0; i < 10; i++) {//Metemos un for para realizar los 10 ciclos
+
+            int estado = (int)Math.floor(Math.random()*10+1);//Declaramos la variable dentro para que en cada ciclo cambie
+            System.out.println("El estado de las plantas del huerto del 1 al 10 es un: "+estado+".\n");
+
+            long start = System.currentTimeMillis();//Declaramos la variable start para poder mostrar el tiempo que se para el hilo
+            try {//Metemos un try and catch para la prueba de errores
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            System.out.println("El hilo esta en pausa durante "+(System.currentTimeMillis()-start)+"milisegundos.\n");
+        }
+
+    }
+
+}

UA1/examen/dev_17/ejercicio2/Humedad.java

@@ -0,0 +1,23 @@
+public class Humedad extends Thread{
+
+    public Humedad() {
+
+    }
+
+    public void run() {
+        for (int i = 0; i < 10 ; i++) {//Metemos un for para realizar los 10 ciclos
+
+            int humedad = (int)Math.floor(Math.random()*100+1);//Declaramos la variable dentro para que en cada ciclo cambie
+            System.out.println("El porcentaje de humedad del huerto es de "+humedad+"%.\n");
+
+            long start = System.currentTimeMillis();//Declaramos la variable start para poder mostrar el tiempo que se para el hilo
+            try {//Metemos un try and catch para la prueba de errores
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            System.out.println("El hilo esta en pausa durante "+(System.currentTimeMillis()-start)+"milisegundos.\n");
+        }
+
+    }
+}

UA1/examen/dev_17/ejercicio2/Main.java

@@ -0,0 +1,15 @@
+public class Main {
+    public static void main(String[] args) {
+
+    Temperatura hilotemp = new Temperatura();
+    Humedad hilohume = new Humedad();
+    Estado hiloestado = new Estado();
+
+    hilotemp.start();//Iniciamos el hilo de temperatura
+    hilohume.start();//Iniciamos el hilo de humedad
+    hiloestado.start();//Iniciamos el hilo de estado
+
+
+    }
+}
+

UA1/examen/dev_17/ejercicio2/Temperatura.java

@@ -0,0 +1,26 @@
+import java.util.Random;
+public class Temperatura extends Thread {
+
+    public Temperatura() {
+
+    }
+
+    public void run() {
+
+        for (int i = 0; i < 10 ; i++) { //Metemos un for para realizar los 10 ciclos
+
+            int temperatura = (int)Math.floor(Math.random()*40+1); //Declaramos la variable dentro para que en cada ciclo cambie
+            System.out.println("La temperatura del huerto es de "+temperatura+" grados.\n");
+
+            long start = System.currentTimeMillis(); //Declaramos la variable start para poder mostrar el tiempo que se para el hilo
+            try { //Metemos un try and catch para la prueba de errores
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            System.out.println("El hilo esta en pausa durante "+(System.currentTimeMillis()-start)+"milisegundos.\n");
+        }
+
+    }
+
+}

UA1/examen/dev_17/ua1ex1.c

@@ -0,0 +1,40 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+
+void main(){
+
+    pid_t pid; //Declaramos la variable pid con tipo pid_t
+    int i;
+
+    printf("Aqui tiene la informacion de los procesos hijos:\n\n"); //Creamos fuera este print para que no se repita todo el rato
+
+    for (i = 1; i<=3; i++){ //Dentro del bucle for creamos los procesos hijos
+        pid = fork();
+
+    if(pid < 0){ //Aqui hacemos un control de errores, por si los procesos hijo no se crean bien
+        printf("Lo sentimos ha habido un error al crear el proceso\n");
+        exit(-1);
+    }
+
+    if(pid == 0){ //Ahora dentro de este if llamamos a la funcion donde mostramos la informacion de cada proceso
+
+        informacion(i);
+        exit(0);
+    }
+    }
+
+    for(i = 1; i<=3; i++){ //Ahora metemos dentro de un bucle el wait null para esperar que finalicen los procesos hijos
+        wait(NULL);//Aqui esperamos que finalicen los procesos hijos
+    }
+
+    printf("\n");
+    printf("Y aqui tiene la informacion del proceso padre:\n\n");
+    printf("El PID del padre es: %d.",getpid()); //Por ultimo mostramos el PID del padre
+
+    return 0;
+}
+
+void informacion(int hijos){ //En la funcion le pasamos el parametro hijos
+    printf("El hijo numero %d, tiene un PID: %d. Y el PID de su padre es: %d. \n",hijos, getpid(),getppid());//Y aqui mostramos su PID y el PID del padre.
+}

UA1/examen/dev_17/ua1ex1_teoria.txt

@@ -0,0 +1,95 @@
+PARTE TEÓRICA
+
+a) Definición de proceso. Ilustra tu solución con un ejemplo. 1 punto. 
+
+Un proceso es un programa en ejecucción que tiene su propio espacio de memoria.
+Los procesos son independientes y no comparten de manera directa memoria con otros procesos.
+
+Un ejemplo de proceso podria ser el proceso de montar un lego:
+
+Montamos un lego{
+Leemos las instrucciones.
+Abrimos las bolsas de las piezas.
+Vemos que piezas van con cada una.
+Montamos las piezas.
+Teminamos la pieza de lego.
+}
+
+
+b) Utilizando tus propias palabras, indica la relación entre hilos y procesos. Ilustra tu solución con un ejemplo. 3 puntos.
+
+La relacion que tiene los hilos con los procesos, es que los hilos son sbuprocesos de ejcucion los cuales derivan de un proceso, los diferentes hilos comparten 
+espacio en memoria, mietras que un proceso tiene su espacio propio
+
+
+Un ejemplo podria ser vestirse:
+
+Vestirse{
+Comenzariamo poniendonos los pantalones.
+Nos ponemos la camiseta.
+Despues los calcetines.
+Y zapatillas.
+}
+
+La accion de vestirse seria el proceso principal, y las demas acciones dentro de vestise serian los hilos.
+Hay que tener en cuenta que los hilos nos permiten programar de forma concurrente los cual significa que los hilos se pueden ejecutar de manera simultanea.
+
+
+c) Utilizando tus propias palabras, indica las características de la programación concurrente y sus ámbitos de aplicación. 3 puntos.
+
+La programacion concurrente es cuando en un programa se realizan varios procesos de manera simultanea los cuales serian los llamados hilos, gracias a esto estos 
+procesos pueden competir por los recursos del sistema o colaborar para realizar un fin comun. 
+
+Algunas de sus caracteristicas pueden ser:
+- Aprovechan mejor la CPU.
+- Incrementa la velocidad de ejecucción.
+- Uso de hilos.
+- Los programas concurrentes tienen un flujo parcial.
+- Leer y escribir objetos compartidos en memoria.
+- Los modulos interactuan enviandose mensajes entre si 
+
+
+
+d) Utilizando tus propias palabras, indica las diferencias entre programación paralela y programación distribuida, sus ventajas e inconvenientes. 3 puntos.
+
+
+La programacion pararela esta hecha para que se ejecute en un sistema que sea multiprocesador, esto significa que varias CPU pueden trabajar a la vez 
+para resolver un problema, gracias a esto este problema se puede dividir en varias pares.
+
+La diferencia con la distribuida es que, la programacion distribuida se trata de que las partes del nustro dispositivo ya sea software o hardware estan distribuidos,
+un ejemplo podria ser que estes trabajando con un compañero en un proyecto mediante internet los dos conjuntos y asi los componentes se conctarian gracias a la red.
+
+Las ventajas e inconvenientes de la programación paralela son:
+
+Ventajas:
+- La ejecucción simultanea.
+- Gracias a esta se disminuye el tiempo de ejecucción.
+- Y poder abordar y solucionar problemas complejos.
+
+Desventajas:
+- Los compiladores y entornos son más complejos.
+- Los programas son más dificiles de escribir.
+- Es tipo de programacion consume más energia.
+- Es más dificil el poder acceder a datos.
+- Y la sincronización y comunicaión tambien es más dificil.
+
+Las ventajas e inconvenientes de la programación distribuida son:
+
+Ventajas:
+- Nos permite compartir recursos y datos.
+- Tendriamos capacidad de crecimiento incremental.
+- Una mayor flexibilidad.
+- Alta disponiblidad.
+- Es de caracter abierto y heterogeneo.
+
+Desventajas:
+- La complejidad aumenta.
+- Varios problemas con las redes de comunicación.
+- Y posibles problemas de seguridad.
+
+
+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/tareas/dev_17/ua1tarea1.c

@@ -0,0 +1,32 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+
+int main(){
+
+    pid_t pid, hijo_pid; //Aqui declaramos las variables de tipo pid_t
+
+    int num; //Declaramos la variable numero que es la que va a recoger la variable que introducimos.
+
+    printf("Buenas introduzca un numero: ");
+
+    scanf("%d", &num); //Pedimos al usuario el numero
+
+    pid = fork();//Se debe crear el fork despues del scanf para que no de error al momento de la creacion de los procesos.  
+
+    if (pid == -1) {//Aqui tendremos  el control de errores el cual nos mostrara un texto en caso de que algo falle.
+        printf("Lo sentimos no hemos podido realizar sus calculos.\n");
+        exit(-1);//Este exit hara que el programa termine.
+    }
+
+    if (pid == 0){
+        printf("Soy el proceso hijo mi PID es: %d. Yo sumare 4 a su numero: %d. \n El resultado es: %d.\n", getpid(), num, num+4);//Con getpid() mostramos el PID del proceso hijo.
+        printf("--------------------------------------\n");
+    }
+    else{
+        hijo_pid = wait(NULL); //wait(NULL) sirve para hacer esperar al proceso padre hasta que termine su accion el proceso hijo.
+        printf("Soy el proceso padre mi PID es: %d. Yo restare 5 a su numero: %d\n El resultado es: %d.\n", getpid(), num, num-5);//Con getpid() mostramos el PID del proceso padre.
+    }
+
+    exit(0);//Y aqui cierra el programa.
+}

UA1/tareas/dev_17/ua1tarea2/Hilo.java

@@ -0,0 +1,23 @@
+import java.sql.SQLOutput;
+import java.util.Scanner;
+public class Hilo implements Runnable { //Implementamos Runnable para poder crear un hilo.
+    @Override
+    public void run() {
+        Scanner scanner = new Scanner(System.in);
+        StringBuilder contenido = new StringBuilder();// Declaramos una variable con StringBuilder sin asignarle ningun valor ya que esta va a almacenar lo que introduzca el usuario.
+
+        System.out.println("Introduzca el contenido que desea, cuando quiera teminar inserte: *\n");
+
+        while (true){
+            String texto = scanner.nextLine();
+
+            if (texto.endsWith("*")) { //Aqui nos encargaremos de que si el contenido acaba con un *, se acabe el bucle.
+                contenido.append(texto.substring(0, texto.indexOf("*")));
+                break;
+            }else {
+                contenido.append(texto).append(System.lineSeparator());//Ahora añadiremos la linea a la cadena que hemos creado con StrignBuilder
+            }
+        }
+        System.out.println("El contenido ha sido leido correctamente, se lo mostramos: \n" + contenido.toString() + "\n");
+    }
+}

UA1/tareas/dev_17/ua1tarea2/Main.java

@@ -0,0 +1,20 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class Main {
+    public static void main(String[] args) {
+    Thread hilo = new Thread(new Hilo()); //Creamos la instancia del hilo de nuestra clase.
+
+    hilo.start();//Iniciamos el hilo.
+
+    try {
+        hilo.join(); //Esperamos a que termine el hilo para continuar con el resto del programa.
+
+    } catch (InterruptedException e) {//Usaremos catch por si surge algun error indicarlo al usuario.
+        System.out.println("Parece ser que el hilo se ha interrumpido.");
+
+    }
+        System.out.println("Gracias por usar nuestro programa, un saludo.");
+    }
+}

UA1/tareas/dev_17/ua1tarea3/Lector.java

@@ -0,0 +1,30 @@
+import java.sql.SQLOutput;
+public class Lector implements Runnable {
+    private String [] args; //Declaro el vector donde se almacenaran los argumentos
+
+    public Lector(String[] args) { //Contructor de la clase.
+        this.args = args;
+    }
+
+    public void run(){
+    if(args.length < 1){ //Si la longitud del vector es menor 1.
+        System.out.println("No hay argumentos el valor es: ");
+        System.exit(1);
+    }
+    for (String arg : args){ //Recorremos el vector para poder leer todos los argumentos.
+        try{
+            int numero = Integer.parseInt(arg);//Mediante esta funcion convierto el argumento a numero.
+            if (numero < 0){ //Si el argumetno es menor que cero entra en el if
+                System.out.println("El argumento es un numero menor que cero, el valor es: ");
+                System.exit(3);
+            }
+        }catch(Exception e){ //Creamos una excepcion por si el argumento es una cadena.
+            System.out.println("El argumento es una cadena, el valor es: ");
+            System.exit(2);
+        }
+    }
+        //Si no es ninguno de los anteriores sera este ultimo.
+        System.out.println("Es otro tipo de argumento, el valor es: ");
+        System.exit(0);
+    }
+}