Wie kann ich einen Interruptible ExecutorService mit Timeouts in Java implementieren?

Unterbrechbarer ExecutorService mit Zeitüberschreitungen

Bei der parallelen Ausführung zeitaufwändiger Aufgaben ist es wichtig, Ausführungszeitüberschreitungen zu kontrollieren, um zu verhindern, dass Aufgaben auf unbestimmte Zeit Ressourcen belegen . In diesem Artikel werden bestehende Implementierungen von ExecutorServices untersucht, die solche Timeout-Funktionen bieten.

Eine Lösung ist ein angepasster ExecutorService, der von den unten aufgeführten Mitwirkenden entwickelt wurde und die Aufgabenausführung überwacht und jede Überschreitung eines vordefinierten Timeouts unterbricht:

import java.util.List;
import java.util.concurrent.*;

public class TimeoutThreadPoolExecutor extends ThreadPoolExecutor {
    // Timeout configuration
    private final long timeout;
    private final TimeUnit timeoutUnit;

    // Task and timeout scheduling
    private final ScheduledExecutorService timeoutExecutor = Executors.newSingleThreadScheduledExecutor();
    private final ConcurrentMap<Runnable, ScheduledFuture> runningTasks = new ConcurrentHashMap<>();

    // Initialize with timeout and scheduling options
    public TimeoutThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, long timeout, TimeUnit timeoutUnit) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        this.timeout = timeout;
        this.timeoutUnit = timeoutUnit;
    }

    // ExecutorService lifecycle management
    @Override
    public void shutdown() {
        timeoutExecutor.shutdown();
        super.shutdown();
    }

    @Override
    public List<Runnable> shutdownNow() {
        timeoutExecutor.shutdownNow();
        return super.shutdownNow();
    }

    // Monitor task execution and initiate timeouts
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        if (timeout > 0) {
            final ScheduledFuture<?> scheduled = timeoutExecutor.schedule(new TimeoutTask(t), timeout, timeoutUnit);
            runningTasks.put(r, scheduled);
        }
    }

    // Handle tasks after completion and cancel timeouts
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        ScheduledFuture timeoutTask = runningTasks.remove(r);
        if (timeoutTask != null) {
            timeoutTask.cancel(false);
        }
    }

    // Task responsible for interrupting long-running tasks
    class TimeoutTask implements Runnable {
        private final Thread thread;

        public TimeoutTask(Thread thread) {
            this.thread = thread;
        }

        @Override
        public void run() {
            thread.interrupt();
        }
    }
}

Diese benutzerdefinierte Implementierung bietet eine bequeme und effiziente Möglichkeit, die Aufgabenausführung zu überwachen und Zeitüberschreitungen durchzusetzen, um ein vorhersehbares Aufgabenverhalten im Multithreading sicherzustellen Umgebungen.

Das obige ist der detaillierte Inhalt vonWie kann ich einen Interruptible ExecutorService mit Timeouts in Java implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!