Programmation asynchrone en Java

// Méthode 1: Extends Thread
class MonThread extends Thread {
    public void run() {
        System.out.println("Thread actif id: " + Thread.currentThread().getId());
    }
}

System.out.println("Thread parent id: "+Thread.currentThread().getId());
MonThread thread = new MonThread();
thread.start();
thread.join();

// Méthode 2: Implements Runnable
Runnable task = () -> {
    System.out.println("Thread actif id: " + Thread.currentThread().getId());
};

new Thread(task).start(); 

// Interface de callback
interface Callback {
    void onComplete(String result);
    void onError(Exception e);
}

import java.util.concurrent.*;

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(() -> {
    try {
        Thread.sleep(1000); // Simulation d'un traitement long
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return "Résultat du traitement";
});


// Vérification de l'état de la tâche
// while (!future.isDone()) {
if (!future.isDone()) {
    System.out.println("Tâche en cours...");
}

// Création d'un CompletableFuture avec simulation de traitement long
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        System.out.println("Début du traitement...");
        TimeUnit.SECONDS.sleep(5);
        return "Résultat du traitement";
    } catch (InterruptedException e) {
        throw new RuntimeException("Erreur pendant le traitement", e);
    }
});

// 1. Traitement non bloquant avec gestion d'erreur
future
    .thenAccept(r -> System.out.println("Traitement asynchrone du résultat: " + r))
    .exceptionally(error -> {
        System.err.println("Erreur: " + error.getMessage());
        return null;
    });

// 2. Chaînage de transformations non bloquantes
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    try {
        TimeUnit.SECONDS.sleep(2); 
        return "Résultat initial dans le thread: " + Thread.currentThread().getId();
    } catch (InterruptedException e) {
        throw new RuntimeException("Erreur pendant le traitement", e);
    }   
    })    
    .thenApply(r -> "Future1: " + r.toUpperCase());

// Création d'un autre CompletableFuture pour démontrer thenCombine
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> " - Additional Data dans un autre thread: " + Thread.currentThread().getId());

// Utilisation de thenCombine pour combiner les résultats des deux futures
CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

// Affichage du résultat combiné
combinedFuture.thenAccept(combinedResult -> System.out.println("Résultat combiné dans le thread: " + Thread.currentThread().getId()+" "+combinedResult));

System.out.println("En attente du résultat...");
try {
    // 3. Attente bloquante avec timeout
    String result = combinedFuture.get(5, TimeUnit.SECONDS);
    System.out.println("Résultat obtenu: " + result);
} catch (InterruptedException | ExecutionException e) {
    System.err.println("Erreur pendant l'exécution: " + e.getMessage());
} catch (TimeoutException e) {
    System.err.println("Timeout dépassé: " + e.getMessage());
}

public class ForkJoinExample extends RecursiveTask<Integer> {
    private final int[] array;
    private final int start, end;

    public ForkJoinExample(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= 10) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            int mid = (start + end) / 2;
            ForkJoinExample leftTask = new ForkJoinExample(array, start, mid);
            ForkJoinExample rightTask = new ForkJoinExample(array, mid, end);
            leftTask.fork();
            return rightTask.compute() + leftTask.join();
        }
    }
}

int[] array = new int[100];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
    array[i] = random.nextInt(100); // Entiers aléatoires entre 0 et 99
}
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinExample task = new ForkJoinExample(array, 0, array.length);
int result = forkJoinPool.invoke(task);
System.out.println("Result: " + result);

import java.util.stream.IntStream;
import java.time.Duration;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import java.util.concurrent.atomic.AtomicInteger;
// Création avec ExecutorService
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
AtomicInteger activeThreads = new AtomicInteger(0);

try {
    final int NB_THREADS = 5;
    // Création de NB_THREADS threads virtuels
    List<Future<Integer>> futures = IntStream.range(0, NB_THREADS).mapToObj(i -> {
        return executor.submit(() -> {
            // Incrémenter le compteur de threads actifs
            int current = activeThreads.incrementAndGet();
            System.out.printf("Thread %d démarré. Threads actifs: %d%n", i, current);
            
            // Simulation de travail
            Thread.sleep(Duration.ofMillis(100 + new Random().nextInt(900)));
            
            // Décrémenter le compteur
            current = activeThreads.decrementAndGet();
            System.out.printf("Thread %d terminé. Threads actifs: %d%n", i, current);
            return i;
        });
    }).collect(Collectors.toList());

    // Attendre la fin de tous les threads
    for (Future<Integer> future : futures) {
        future.get();
    }
} finally {
    executor.shutdown();
}

System.out.println("Tous les threads sont terminés");