Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Executors.newFixedThreadPool — pula wątków o stałym rozmiarze

Pula o rozmiarze 3 może obsługiwać najwyżej trzy zadania równocześnie. Nie oznacza to, że wystartują w tej samej chwili. Gdy wszystkie wątki są zajęte, kolejne zadania czekają w kolejce.

Wersja: Java SE 21

Składnia

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

// Static methods declared by Executors:
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

// Example call:
ExecutorService pool = Executors.newFixedThreadPool(3);

Executors.newFixedThreadPool to statyczna metoda fabrykująca klasy java.util.concurrent.Executors. Zwraca ExecutorService, który wykorzystuje te same wątki robocze do obsługi kolejnych zadań. Executors.newFixedThreadPool(3) pozwala obsługiwać najwyżej trzy zadania naraz. To górny limit, a nie gwarancja, że trzy zadania ruszą w tej samej chwili, będą wykonywane fizycznie równolegle lub zakończą się w kolejności zgłoszenia.

Gdy wszystkie wątki robocze są zajęte, następne zadania czekają we wspólnej kolejce bez ustalonego limitu pojemności. Rozmiar puli ogranicza liczbę wątków, nie liczbę oczekujących zadań. Jeżeli zadania przez dłuższy czas napływają szybciej, niż pula je kończy, kolejka może zużywać coraz więcej pamięci. Jeśli potrzebujesz limitu kolejki, użyj ThreadPoolExecutor z kolejką o ograniczonej pojemności i świadomie dobraną polityką odrzucania.

Przeciążenie z samym int nThreads korzysta z domyślnej fabryki, która tworzy wątki niebędące demonami. Przeciążenie z ThreadFactory używa przekazanej fabryki do tworzenia wątków na żądanie. Oba zgłaszają IllegalArgumentException dla nThreads <= 0; drugie zgłasza też NullPointerException, jeśli fabryka to null. Jeżeli przed zamknięciem wątek roboczy zakończy działanie wskutek awarii, pula w razie potrzeby zastąpi go nowym, aby obsłużyć kolejne zadania.

Zamykaj pulę, gdy nie jest już potrzebna: domyślne wątki mogą podtrzymywać działanie JVM. shutdown() przestaje przyjmować nowe zadania, ale pozwala wykonać już zgłoszone i nie czeka na zakończenie. W Java SE 21 try z zasobami wywołuje close(), które rozpoczyna zamykanie i czeka na zakończenie pracy puli.

Przykłady

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FixedPoolDemo {
    public static void main(String[] args)
            throws InterruptedException, ExecutionException {
        CountDownLatch started = new CountDownLatch(3);
        CountDownLatch release = new CountDownLatch(1);

        try (ExecutorService pool = Executors.newFixedThreadPool(3)) {
            Callable<Void> holdWorker = () -> {
                started.countDown();
                release.await();
                return null;
            };

            Future<Integer> fourth;
            try {
                for (int i = 0; i < 3; i++) {
                    pool.submit(holdWorker);
                }
                started.await();
                fourth = pool.submit(() -> 4);
                System.out.println("Fourth task done before release: " + fourth.isDone());
            } finally {
                release.countDown();
            }
            System.out.println("Fourth task result: " + fourth.get());
        }
    }
}

Wynik

Fourth task done before release: false
Fourth task result: 4

Pierwsze trzy zadania zajmują po jednym wątku roboczym i nie mogą się zakończyć przed zwolnieniem blokady. Dlatego `isDone()` czwartego zadania zwraca `false`. Po zwolnieniu blokady `get()` czeka w razie potrzeby na wynik `4`. Przykład pokazuje nakładanie się zadań w czasie, a nie ich start w tej samej chwili.

Powiązane lekcje

  • Java · Lekcja 50 · Średniozaawansowany · Wersja: 2

Źródła