Ce este un pool de fire de execuție?

Poolul de fire (ThreadPool) este un grup de fire de lucru gestionate de o entitate unică, care primește sarcini și le distribuie între firele disponibile. În loc să creeze un nou fir pentru fiecare sarcină, pool-ul reutilizează cele existente.

Principalele avantaje:

• Reducerea costurilor: Crearea și distrugerea firelor consumă timp și resurse. Pool-ul elimină această necesitate.
• Gestionarea resurselor: Limitează numărul maxim de fire care rulează simultan, prevenind epuizarea resurselor sistemului.
• Îmbunătățirea performanței: Gestionează coada de sarcini, ceea ce poate crește capacitatea de procesare a aplicațiilor.
• Ușurința de gestionare: Oferă un mecanism centralizat pentru executarea sarcinilor asincrone.

În Java, pentru a lucra cu pool-uri de fire, se folosește pachetul java.util.concurrent. Interfețele și clasele principale:

• Executor: Interfață pentru executarea sarcinilor.
• ExecutorService: Extindere a Executor care oferă metode pentru gestionarea ciclului de viață al pool-ului și obținerea rezultatelor.
• Executors: Clasă auxiliară pentru crearea implementărilor standard ale ExecutorService, de exemplu:
  • newFixedThreadPool(int nThreads): Pool cu un număr fix de fire.
  • newCachedThreadPool(): Pool care creează fire după nevoie și reutilizează cele inactive.
  • newSingleThreadExecutor(): Pool cu un singur fir de lucru.
  • newScheduledThreadPool(int corePoolSize): Pool pentru executarea sarcinilor programate.
• ThreadPoolExecutor: Implementare flexibilă a ExecutorService care permite ajustarea mai fină a comportamentului pool-ului.

Exemplu de utilizare a ExecutorService:

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

// Exemplu de sarcină pentru executare în pool
class MyTask implements Runnable {
    private final int taskId;

    public MyTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Executarea sarcinii " + taskId + " de către thread-ul " + Thread.currentThread().getName());
        try {
            Thread.sleep(100); // Simulare de lucru
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class ThreadPoolExample {
    public static void main(String[] args) {
        // Crearea unui pool cu un număr fix de fire
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // Trimiterea sarcinilor pentru executare
        for (int i = 0; i < 10; i++) {
            executorService.submit(new MyTask(i));
        }

        // Închiderea corectă a pool-ului după finalizarea tuturor sarcinilor
        executorService.shutdown();
    }
}

Ciclul de viață al pool-ului este gestionat prin metodele shutdown() și shutdownNow() pentru o oprire corectă.