База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Пулове с фиксиран брой нишки, капацитет на опашката и нормално спиране

Създай два пула с по две работни нишки, сравни опашките им и вземи резултатите, преди да извикаш `shutdown()` и за двата пула.

Версия: Java SE 21

Синтаксис

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

В Java SE 21 статичният метод Executors.newFixedThreadPool(2) от пакета java.util.concurrent връща ExecutorService, който използва повторно работните си нишки. Най-много две нишки изпълняват задачи едновременно. Когато и двете са заети, допълнителните задачи чакат в обща опашка без зададен предел на капацитета. Следователно ограничението на броя нишки не ограничава броя чакащи задачи. Ако задачите пристигат по-бързо, отколкото пулът ги завършва, опашката може да расте и да заема повече памет.

Претовареният вариант Executors.newFixedThreadPool(nThreads, threadFactory) използва подадената ThreadFactory за създаване на нишките, но не ограничава опашката. И двата варианта хвърлят IllegalArgumentException при nThreads <= 0; вторият хвърля NullPointerException, ако фабриката е null.

За да ограничиш броя чакащи задачи, настрой основния и максималния размер на ThreadPoolExecutor на 2 и използвай ArrayBlockingQueue<>(2). Така най-много две задачи могат да се изпълняват от работните нишки, а най-много още две да чакат в опашката. Ако пулът не може да приеме задача, защото и двете нишки са заети, а опашката е пълна, AbortPolicy хвърля RejectedExecutionException, вместо да чака да се освободи място. Тази политика отхвърля и задачи, подадени след началото на спирането.

ExecutorService.shutdown() определя правилата за нормално спиране, а ThreadPoolExecutor.shutdown() ги реализира: вече приетите задачи могат да се изпълнят, новите се отхвърлят, а извикването не изчаква завършването им. Повторно извикване няма допълнителен ефект. Ако активен мениджър на сигурността откаже разрешение, е възможно да възникне SecurityException. При нормално изпълнение вземи всички нужни резултати чрез Future.get(), преди да спреш двата пула в finally, който се изпълнява и при грешка. get() изчаква конкретна задача при нужда; за да изчакаш с ограничение във времето спирането на целия пул след shutdown(), използвай awaitTermination().

Примери

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

Резултат

fixed=5, bounded=12

Програмата подава по две задачи на всеки пул и при нормално изпълнение взема четирите резултата преди спирането. Отпечатва само двете суми, по една за всеки пул, в постоянен ред, независимо от планирането на нишките. Примерът не предизвиква умишлено запълване на опашката или отхвърляне на задача.

Свързани уроци

  • Java · Урок 42 · Напреднало · Версия: 2

Източници