Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / Java

Executors.newFixedThreadPool — skup dretvi fiksne veličine

Skup veličine 3 može obrađivati najviše tri zadatka istodobno, ali oni ne moraju započeti u istom trenutku. Kad su sve dretve zauzete, dodatni zadaci čekaju u redu.

Verzija: Java SE 21

Sintaksa

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 statička je tvornička metoda klase java.util.concurrent.Executors. Vraća ExecutorService koji ponovno koristi radne dretve za različite zadatke. Uz Executors.newFixedThreadPool(3) istodobno se mogu obrađivati najviše tri zadatka. To je gornja granica, a ne jamstvo da će započeti u istom trenutku, izvršavati se stvarno paralelno ili završiti redoslijedom predaje.

Kad su sve radne dretve zauzete, dodatni zadaci čekaju u zajedničkom redu bez zadanog ograničenja kapaciteta. Veličina skupa ograničava broj dretvi, a ne broj zadataka na čekanju. Ako zadaci dulje pristižu brže nego što ih skup dovršava, red može zauzimati sve više memorije. Ako trebaš ograničiti broj zadataka na čekanju, upotrijebi ThreadPoolExecutor s ograničenim redom i promišljeno odabranom politikom odbijanja.

Inačica koja prima samo int nThreads koristi zadanu tvornicu, koja stvara nedemonske dretve. Inačica s ThreadFactory koristi zadanu joj tvornicu za stvaranje dretvi po potrebi. Obje bacaju IllegalArgumentException ako vrijedi nThreads <= 0; druga baca i NullPointerException ako je tvornica null. Ako radna dretva prije gašenja završi zbog pogreške, skup je po potrebi zamjenjuje kako bi mogao izvršavati kasnije zadatke.

Ugasi skup kad ti više ne treba: dretve iz zadane tvornice mogu održavati JVM aktivnim. shutdown() prestaje prihvaćati nove zadatke, dopušta izvršavanje već predanih i ne čeka završetak izvršitelja. U Java SE 21, try s resursima poziva close(), koji pokreće gašenje i čeka da se izvršitelj zaustavi.

Primjeri

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());
        }
    }
}

Rezultat

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

Svaki od prva tri zadatka zauzima jednu radnu dretvu i ne može završiti prije otpuštanja blokade. Zato `isDone()` za četvrti zadatak vraća `false`. Nakon otpuštanja `get()` po potrebi čeka rezultat `4`. Primjer pokazuje vremensko preklapanje zadataka, a ne njihov početak u istom trenutku.

Povezane lekcije

  • Java · Lekcija 50 · Srednje · Verzija: 2

Izvori