Comment puis-je implémenter un délai d'attente pour les tâches pouvant être interrompues dans un ExecutorService ?

ExecutorService avec délai d'attente pour les tâches pouvant être interrompues

Lors de l'exécution simultanée de tâches, il est souvent souhaitable de disposer d'un mécanisme permettant d'interrompre progressivement les tâches qui dépassent un délai spécifié. temps mort. Ceci est particulièrement utile dans les situations où des tâches de longue durée peuvent entraîner des blocages d'applications ou des problèmes de performances.

Implémentation d'un TimeoutExecutorService

Voici une implémentation d'un TimeoutThreadPoolExecutor qui étend la ThreadPoolExecutor standard et intègre un délai d'attente fonctionnalité :

class TimeoutThreadPoolExecutor extends ThreadPoolExecutor {

    private final long timeout;
    private final TimeUnit timeoutUnit;

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

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

    // Override methods to implement timeout behavior

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        if (timeout > 0) {
            ScheduledFuture scheduled = timeoutExecutor.schedule(new TimeoutTask(t), timeout, timeoutUnit);
            runningTasks.put(r, scheduled);
        }
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        ScheduledFuture timeoutTask = runningTasks.remove(r);
        if (timeoutTask != null) {
            timeoutTask.cancel(false);
        }
    }

    // Timeout task to interrupt threads
    class TimeoutTask implements Runnable {

        private final Thread thread;

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

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

Utilisation :

Pour utiliser le TimeoutThreadPoolExecutor, vous pouvez simplement l'instancier avec une valeur de délai d'attente :

TimeoutThreadPoolExecutor executor = new TimeoutThreadPoolExecutor(
    4, // corePoolSize
    8, // maximumPoolSize
    1, // keepAliveTime
    TimeUnit.SECONDS, // timeUnit
    new LinkedBlockingQueue<>(), // workQueue
    5, // timeout
    TimeUnit.SECONDS // timeoutUnit
);

Ensuite , soumettez les tâches à l'exécuteur testamentaire comme d'habitude :

executor.submit(() -> {
    // long-running task
});

Si une tâche prend plus de temps supérieur au délai d'expiration spécifié, le thread exécutant la tâche sera interrompu, provoquant la fin de la tâche correctement.

Solution alternative

Une autre approche pour implémenter un délai d'attente pour une tâche consiste à utiliser ScheduledExecutorService comme suggéré dans la réponse. Cela implique de soumettre la tâche en tant que Callable et de conserver le futur créé. Une deuxième tâche peut alors être programmée pour annuler le futur après une certaine période, interrompant ainsi la tâche.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!