Merge pull request mouredev#6413 from eulogioep/main

#15 - java, javascript, php y typescript

Author: Roswell468

Roadmap/15 - ASINCRONÍA/java/eulogioep.java

@@ -0,0 +1,72 @@
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class eulogioep {
+    
+    /**
+     * Método principal que demuestra el uso de asincronía en Java
+     */
+    public static void main(String[] args) {
+        // Demostración básica
+        System.out.println("=== Demostración Básica ===");
+        ejecutarTareaAsincrona("TareaEjemplo", 2);
+        
+        // Para asegurar que la demostración básica termine antes de la extra
+        try {
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        
+        // Dificultad Extra
+        System.out.println("\n=== Dificultad Extra ===");
+        dificultadExtra();
+    }
+    
+    /**
+     * Ejecuta una tarea asíncrona con un nombre y duración especificados
+     * @param nombre Nombre de la tarea
+     * @param segundos Duración de la tarea en segundos
+     * @return CompletableFuture<Void> que representa la tarea asíncrona
+     */
+    public static CompletableFuture<Void> ejecutarTareaAsincrona(String nombre, int segundos) {
+        return CompletableFuture.runAsync(() -> {
+            try {
+                System.out.println(nombre + " - Iniciando...");
+                System.out.println(nombre + " - Durará " + segundos + " segundos");
+                Thread.sleep(segundos * 1000);
+                System.out.println(nombre + " - Finalizada");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+    }
+    
+    /**
+     * Implementación de la dificultad extra
+     * Ejecuta las tareas C, B y A en paralelo y luego D cuando las anteriores terminan
+     */
+    public static void dificultadExtra() {
+        // Crear un ExecutorService para manejar los hilos
+        ExecutorService executor = Executors.newFixedThreadPool(3);
+        
+        // Crear las tareas asíncronas
+        CompletableFuture<Void> tareaC = ejecutarTareaAsincrona("Tarea C", 3);
+        CompletableFuture<Void> tareaB = ejecutarTareaAsincrona("Tarea B", 2);
+        CompletableFuture<Void> tareaA = ejecutarTareaAsincrona("Tarea A", 1);
+        
+        // Esperar a que todas las tareas terminen y luego ejecutar D
+        CompletableFuture.allOf(tareaC, tareaB, tareaA)
+            .thenRun(() -> ejecutarTareaAsincrona("Tarea D", 1));
+        
+        // Esperar a que todo termine antes de cerrar el programa
+        try {
+            executor.shutdown();
+            executor.awaitTermination(10, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+}

Roadmap/15 - ASINCRONÍA/javascript/eulogioep.js

@@ -0,0 +1,55 @@
+/**
+ * Función asíncrona que simula una tarea que tarda un tiempo específico
+ * @param {string} nombre - Nombre de la tarea
+ * @param {number} segundos - Duración de la tarea en segundos
+ * @returns {Promise} Una promesa que se resuelve cuando la tarea termina
+ */
+function ejecutarTareaAsincrona(nombre, segundos) {
+    return new Promise(resolve => {
+        console.log(`${nombre} - Iniciando...`);
+        console.log(`${nombre} - Durará ${segundos} segundos`);
+        
+        setTimeout(() => {
+            console.log(`${nombre} - Finalizada`);
+            resolve();
+        }, segundos * 1000);
+    });
+}
+
+/**
+ * Demostración básica de una tarea asíncrona
+ */
+async function demostracionBasica() {
+    console.log("=== Demostración Básica ===");
+    await ejecutarTareaAsincrona("TareaEjemplo", 2);
+}
+
+/**
+ * Implementación de la dificultad extra
+ * Ejecuta las tareas C, B y A en paralelo y luego D cuando las anteriores terminan
+ */
+async function dificultadExtra() {
+    console.log("\n=== Dificultad Extra ===");
+    
+    // Ejecutar tareas C, B y A en paralelo
+    const tareaC = ejecutarTareaAsincrona("Tarea C", 3);
+    const tareaB = ejecutarTareaAsincrona("Tarea B", 2);
+    const tareaA = ejecutarTareaAsincrona("Tarea A", 1);
+    
+    // Esperar a que todas las tareas terminen
+    await Promise.all([tareaC, tareaB, tareaA]);
+    
+    // Ejecutar tarea D después de que las otras hayan terminado
+    await ejecutarTareaAsincrona("Tarea D", 1);
+}
+
+/**
+ * Función principal que ejecuta todas las demostraciones
+ */
+async function main() {
+    await demostracionBasica();
+    await dificultadExtra();
+}
+
+// Ejecutar el programa
+main().catch(error => console.error('Error:', error));

Roadmap/15 - ASINCRONÍA/php/eulogioep.php

@@ -0,0 +1,101 @@
+<?php
+
+/**
+ * Clase para manejar tareas asíncronas
+ */
+class TareaAsincrona {
+    private $nombre;
+    private $segundos;
+    private $pid;
+
+    /**
+     * Constructor de la clase
+     * @param string $nombre Nombre de la tarea
+     * @param int $segundos Duración de la tarea en segundos
+     */
+    public function __construct($nombre, $segundos) {
+        $this->nombre = $nombre;
+        $this->segundos = $segundos;
+    }
+
+    /**
+     * Ejecuta la tarea de forma asíncrona
+     * @return bool True si la tarea se inició correctamente
+     */
+    public function ejecutar() {
+        // Crear un proceso hijo
+        $pid = pcntl_fork();
+        
+        if ($pid == -1) {
+            die("No se pudo crear el proceso hijo\n");
+        } else if ($pid) {
+            // Proceso padre
+            $this->pid = $pid;
+            return true;
+        } else {
+            // Proceso hijo
+            echo "{$this->nombre} - Iniciando...\n";
+            echo "{$this->nombre} - Durará {$this->segundos} segundos\n";
+            sleep($this->segundos);
+            echo "{$this->nombre} - Finalizada\n";
+            exit(0);
+        }
+    }
+
+    /**
+     * Espera a que la tarea termine
+     */
+    public function esperar() {
+        if ($this->pid) {
+            pcntl_waitpid($this->pid, $status);
+        }
+    }
+}
+
+/**
+ * Demostración básica de una tarea asíncrona
+ */
+function demostracionBasica() {
+    echo "=== Demostración Básica ===\n";
+    $tarea = new TareaAsincrona("TareaEjemplo", 2);
+    $tarea->ejecutar();
+    $tarea->esperar();
+}
+
+/**
+ * Implementación de la dificultad extra
+ */
+function dificultadExtra() {
+    echo "\n=== Dificultad Extra ===\n";
+    
+    // Crear las tareas
+    $tareaC = new TareaAsincrona("Tarea C", 3);
+    $tareaB = new TareaAsincrona("Tarea B", 2);
+    $tareaA = new TareaAsincrona("Tarea A", 1);
+    $tareaD = new TareaAsincrona("Tarea D", 1);
+
+    // Ejecutar C, B y A en paralelo
+    $tareaC->ejecutar();
+    $tareaB->ejecutar();
+    $tareaA->ejecutar();
+
+    // Esperar a que terminen C, B y A
+    $tareaC->esperar();
+    $tareaB->esperar();
+    $tareaA->esperar();
+
+    // Ejecutar D después de que las otras hayan terminado
+    $tareaD->ejecutar();
+    $tareaD->esperar();
+}
+
+// Función principal
+function main() {
+    demostracionBasica();
+    dificultadExtra();
+}
+
+// Ejecutar el programa
+main();
+
+?>

Roadmap/15 - ASINCRONÍA/typescript/eulogioep.ts

@@ -0,0 +1,130 @@
+/**
+ * Interfaz que define la estructura de una tarea asíncrona
+ */
+interface AsyncTask {
+    name: string;
+    duration: number;
+    status: 'pending' | 'running' | 'completed';
+    startTime?: Date;
+    endTime?: Date;
+}
+
+/**
+ * Clase que implementa una tarea asíncrona
+ */
+class Task implements AsyncTask {
+    public status: 'pending' | 'running' | 'completed' = 'pending';
+    public startTime?: Date;
+    public endTime?: Date;
+
+    constructor(
+        public name: string,
+        public duration: number
+    ) {}
+
+    /**
+     * Ejecuta la tarea y retorna una promesa
+     * @returns Promise<void>
+     */
+    async execute(): Promise<void> {
+        this.status = 'running';
+        this.startTime = new Date();
+        
+        console.log(`${this.name} - Iniciando...`);
+        console.log(`${this.name} - Durará ${this.duration} segundos`);
+        
+        return new Promise<void>((resolve) => {
+            setTimeout(() => {
+                this.status = 'completed';
+                this.endTime = new Date();
+                console.log(`${this.name} - Finalizada`);
+                resolve();
+            }, this.duration * 1000);
+        });
+    }
+}
+
+/**
+ * Clase que gestiona la ejecución de tareas asíncronas
+ */
+class TaskManager {
+    private tasks: Map<string, Task> = new Map();
+
+    /**
+     * Añade una nueva tarea al gestor
+     * @param name Nombre de la tarea
+     * @param duration Duración en segundos
+     */
+    addTask(name: string, duration: number): void {
+        this.tasks.set(name, new Task(name, duration));
+    }
+
+    /**
+     * Ejecuta una demostración básica con una sola tarea
+     */
+    async runBasicDemo(): Promise<void> {
+        console.log("=== Demostración Básica ===");
+        const task = new Task("TareaEjemplo", 2);
+        await task.execute();
+    }
+
+    /**
+     * Ejecuta la dificultad extra del ejercicio
+     */
+    async runExtraChallenge(): Promise<void> {
+        console.log("\n=== Dificultad Extra ===");
+        
+        // Crear tareas
+        this.addTask("Tarea C", 3);
+        this.addTask("Tarea B", 2);
+        this.addTask("Tarea A", 1);
+        this.addTask("Tarea D", 1);
+
+        // Ejecutar tareas C, B y A en paralelo
+        const parallelTasks = ["Tarea C", "Tarea B", "Tarea A"].map(name => 
+            this.tasks.get(name)!.execute()
+        );
+
+        // Esperar a que terminen las tareas paralelas
+        await Promise.all(parallelTasks);
+
+        // Ejecutar tarea D
+        await this.tasks.get("Tarea D")!.execute();
+    }
+
+    /**
+     * Obtiene estadísticas de ejecución de las tareas
+     */
+    getStats(): string {
+        let stats = "\nEstadísticas de ejecución:\n";
+        this.tasks.forEach(task => {
+            if (task.startTime && task.endTime) {
+                const executionTime = 
+                    (task.endTime.getTime() - task.startTime.getTime()) / 1000;
+                stats += `${task.name}: ${executionTime.toFixed(2)} segundos\n`;
+            }
+        });
+        return stats;
+    }
+}
+
+/**
+ * Función principal que ejecuta todo el programa
+ */
+async function main(): Promise<void> {
+    const manager = new TaskManager();
+
+    try {
+        await manager.runBasicDemo();
+        await manager.runExtraChallenge();
+        console.log(manager.getStats());
+    } catch (error) {
+        console.error("Error durante la ejecución:", error);
+    }
+}
+
+// Ejecutar el programa
+main().catch(error => console.error('Error:', error));
+
+// Para compilar: tsc nombrearchivo.ts
+// Para ejecutar: node nombrearchivo.js