Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / Java

Skupovi dretvi fiksne veličine, kapacitet reda i uredno gašenje

Stvori dva skupa s po dvije radne dretve, usporedi kapacitete njihovih redova i preuzmi rezultate prije poziva `shutdown()` za oba skupa.

Verzija: Java SE 21

Sintaksa

In java.util.concurrent:
public static ExecutorService Executors.newFixedThreadPool(int nThreads)
public static ExecutorService Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
void ExecutorService.shutdown()
public void ThreadPoolExecutor.shutdown()

Bounded-queue alternative:
new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy())

U izdanju Java SE 21 statička metoda Executors.newFixedThreadPool(2) iz paketa java.util.concurrent vraća ExecutorService koji ponovno koristi radne dretve. Zadatke istodobno obrađuju najviše dvije dretve. Kada su obje zauzete, dodatni zadaci čekaju u zajedničkom redu bez postavljene granice kapaciteta. Ograničenje broja dretvi stoga ne ograničava broj zadataka na čekanju. Ako zadaci pristižu brže nego što ih skup dovršava, red može rasti i zauzimati više memorije.

Preopterećena inačica Executors.newFixedThreadPool(nThreads, threadFactory) stvara dretve pomoću zadane ThreadFactory, ali ne ograničava red. Obje inačice bacaju IllegalArgumentException kada je nThreads <= 0; druga baca NullPointerException ako je tvornica null.

Za ograničavanje broja zadataka na čekanju postavi osnovnu i maksimalnu veličinu ThreadPoolExecutor na 2 i upotrijebi ArrayBlockingQueue<>(2). Tada se najviše dva zadatka mogu izvršavati na radnim dretvama, a najviše još dva mogu čekati u redu. Ako skup ne može prihvatiti zadatak jer su obje dretve zauzete, a red pun, AbortPolicy baca RejectedExecutionException umjesto čekanja na slobodno mjesto. Ta politika odbija i zadatke predane nakon početka gašenja.

ExecutorService.shutdown() definira pravila urednog gašenja, a ThreadPoolExecutor.shutdown() ih provodi: ranije prihvaćeni zadaci mogu se izvršiti, novi se odbijaju, a poziv ne čeka dovršetak. Ponovni poziv nema dodatnog učinka. Ako aktivni upravitelj sigurnosti uskrati dopuštenje, može doći do SecurityException. Pri uobičajenom tijeku preuzmi sve potrebne rezultate pomoću Future.get() prije gašenja obaju skupova u bloku finally, koji se izvršava i u slučaju pogreške. get() po potrebi čeka određeni zadatak; za čekanje na završetak cijelog skupa uz vremensko ograničenje nakon shutdown() upotrijebi awaitTermination().

Primjeri

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class PoolDemo {
    public static void main(String[] args)
            throws InterruptedException, ExecutionException {
        ExecutorService fixed = Executors.newFixedThreadPool(2);
        ThreadPoolExecutor bounded = new ThreadPoolExecutor(
                2, 2, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy());

        try {
            Future<Integer> first = fixed.submit(() -> 2);
            Future<Integer> second = fixed.submit(() -> 3);
            Future<Integer> third = bounded.submit(() -> 5);
            Future<Integer> fourth = bounded.submit(() -> 7);

            int fixedSum = first.get() + second.get();
            int boundedSum = third.get() + fourth.get();
            System.out.println("fixed=" + fixedSum + ", bounded=" + boundedSum);
        } finally {
            try {
                fixed.shutdown();
            } finally {
                bounded.shutdown();
            }
        }
    }
}

Rezultat

fixed=5, bounded=12

Program predaje po dva zadatka svakom skupu i pri uobičajenom tijeku preuzima sva četiri rezultata prije gašenja. Ispisuje samo dva zbroja, po jedan za svaki skup, fiksnim redoslijedom neovisno o raspoređivanju dretvi. Primjer ne izaziva namjerno popunjavanje reda ni odbijanje zadatka.

Povezane lekcije

  • Java · Lekcija 42 · Napredno · Verzija: 2

Izvori