java executorservice Archivi

Introduzione L’utilizzo di ExecutorService in Java è una pratica comune per la gestione di thread e task asincroni. Quando si avviano più task simultaneamente, è fondamentale sapere come verificare se tutti i task sono completati. In questa guida, esploreremo in dettaglio come usare ExecutorService per controllare lo stato dei task, quali metodi sono più efficaci e come gestire il flusso in modo sicuro e performante. Cos'è Java ExecutorService ExecutorService fa parte del pacchetto java.util.concurrent. È una delle API principali per l'esecuzione di task concorrenti. Permette di astrarre la gestione dei thread e offre metodi come submit(), invokeAll() e shutdown(). Esecuzione di più task con ExecutorService Ecco un esempio semplice di come lanciare più task in parallelo usando ExecutorService: ExecutorService executor Executors.newFixedThreadPool(5); List > futures new ArrayList<>(); for (int i 0; i task () -> { Thread.sleep(1000); return "Task " + taskId + " completato"; }; futures.add(executor.submit(task)); } Come verificare se tutti i task sono completati Una delle domande più comuni è: come controllare se tutti i Future sono completati?Ecco alcuni approcci pratici. 1. Controllare ogni Future con isDone() Ogni oggetto Future ha il metodo isDone(). Puoi verificare lo stato di ogni task iterando sulla lista: boolean allDone futures.stream().allMatch(Future::isDone); Questo codice restituisce true solo quando tutti i task sono completati. Puoi anche usare un ciclo per controllare periodicamente: while (true) { boolean allDone true; for (Future future : futures) { if (!future.isDone()) { allDone false; break; } } if (allDone) { System.out.println("Tutti i task sono stati completati."); break; } Thread.sleep(500); // Polling interval } Questo approccio è semplice ma efficace per controllare l'avanzamento. 2. Usare invokeAll() per attendere il completamento Un’alternativa pulita è usare invokeAll(), che blocca finché tutti i task non sono completati: List > tasks new ArrayList<>(); for (int i 0; i { Thread.sleep(1000); return "Task " + taskId + " completato"; }); } List > results executor.invokeAll(tasks); for (Future result : results) { System.out.println(result.get()); } Con invokeAll(), non serve controllare ogni Future, poiché il metodo restituisce solo al termine di tutti i task. 3. Usare CompletionService per monitorare i task completati Se vuoi elaborare i risultati appena un task termina, puoi usare ExecutorCompletionService: ExecutorService executor Executors.newFixedThreadPool(5); CompletionService completionService new ExecutorCompletionService<>(executor); for (int i 0; i { Thread.sleep(1000); return "Task " + taskId + " completato"; }); } for (int i 0; i result completionService.take(); // blocca finché un task è completato System.out.println(result.get()); } Questo metodo è utile per processare i risultati nell’ordine in cui i task finiscono, senza attese inutili. 4. Shutdown e awaitTermination Una volta inviati tutti i task, puoi chiudere l’ExecutorService e attendere la sua terminazione: executor.shutdown(); executor.awaitTermination(1, TimeUnit.MINUTES); if (executor.isTerminated()) { System.out.println("Tutti i task sono completati."); } Questa combinazione è utile per task di lunga durata o per evitare di lasciare thread pendenti. 5. Esempio completo con controllo dello stato dei task ExecutorService executor Executors.newFixedThreadPool(4); List > futures new ArrayList<>(); for (int i 0; i { Thread.sleep(1500); return "Task " + id + " finito"; })); } while (true) { boolean allDone futures.stream().allMatch(Future::isDone); if (allDone) { System.out.println("Tutti i task sono terminati."); break; } System.out.println("In attesa del completamento..."); Thread.sleep(500); } for (Future future : futures) { System.out.println(future.get()); } executor.shutdown(); Questo codice mostra un controllo continuo dello stato dei task e stampa i risultati alla fine. Best Practices da seguire Non dimenticare mai di chiamare shutdown() per evitare memory leak. Evita il busy waiting, usa Thread.sleep() o awaitTermination() dove possibile. Non usare .get() senza controllo, perché blocca il thread chiamante. Gestisci correttamente le eccezioni, specialmente InterruptedException e ExecutionException. Conclusione Controllare se tutti i task sono completati in ExecutorService è essenziale per una gestione efficace della concorrenza. Usando metodi come isDone(), invokeAll() e awaitTermination(), puoi garantire che i tuoi thread si comportino in modo prevedibile e sicuro. Scegli l'approccio più adatto alla tua esigenza, tenendo conto di performance e semplicità.