Wat is een threadpool?

De ThreadPool (ThreadPool) is een groep werkende threads die worden beheerd door een enkele entiteit die taken ontvangt en deze verdeelt over de beschikbare threads. In plaats van voor elke taak een nieuwe thread te maken, wordt de bestaande hergebruikt.

Belangrijkste voordelen:

• Kostenbesparing: Het aanmaken en vernietigen van threads kost tijd en resources. De pool elimineert deze noodzaak.
• Resourcebeheer: Beperkt het maximale aantal gelijktijdig uitgevoerde threads, waardoor systeembronnen niet uitgeput raken.
• Verbeterde prestaties: Beheert de taakwachtrij, wat de doorvoer van applicaties kan verhogen.
• Gebruiksgemak: Biedt een gecentraliseerd mechanisme voor het uitvoeren van asynchrone taken.

In Java wordt de package java.util.concurrent gebruikt voor het werken met threadpools. De belangrijkste interfaces en klassen:

• Executor: Interface voor het uitvoeren van taken.
• ExecutorService: Uitbreiding van Executor die methoden biedt voor het beheren van de levenscyclus van de pool en het verkrijgen van resultaten.
• Executors: Hulpkclass voor het maken van standaardimplementaties van ExecutorService, bijvoorbeeld:
  • newFixedThreadPool(int nThreads): Pool met vaste hoeveelheid threads.
  • newCachedThreadPool(): Pool die threads aanmaakt naar behoefte en inactieve hergebruikt.
  • newSingleThreadExecutor(): Pool met één werkende thread.
  • newScheduledThreadPool(int corePoolSize): Pool voor het uitvoeren van geplande taken.
• ThreadPoolExecutor: Flexibele implementatie van ExecutorService die het gedrag van de pool fijn afstemt.

Voorbeeld van gebruik van ExecutorService:

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

// Voorbeeld van taak voor uitvoering in de pool
class MyTask implements Runnable {
    private final int taskId;

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

    @Override
    public void run() {
        System.out.println("Uitvoeren van taak " + taskId + " door thread " + Thread.currentThread().getName());
        try {
            Thread.sleep(100); // Werk simulatie
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class ThreadPoolExample {
    public static void main(String[] args) {
        // Creëer een pool met vaste hoeveelheid threads
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // Verzend taken voor uitvoering
        for (int i = 0; i < 10; i++) {
            executorService.submit(new MyTask(i));
        }

        // Correct afsluiten van de pool na voltooiing van alle taken
        executorService.shutdown();
    }
}

De levenscyclus van de pool wordt beheerd door de methoden shutdown() en shutdownNow() voor een correcte stop.