Comment résoudre l'exception de délai d'attente d'interruption du thread Java (InterruptedTimeoutException)

Comment résoudre l'exception de délai d'attente d'interruption de thread Java (InterruptedTimeoutException)

Introduction :
En programmation simultanée, l'opération d'interruption de thread est un moyen technique très courant. Il peut être utilisé pour terminer des threads qui n'ont plus besoin de s'exécuter ou pour coordonner plusieurs threads. Cependant, il arrive parfois que l'interruption du thread ne se déroule pas correctement et qu'un délai d'interruption puisse survenir. Cet article explique comment résoudre l'exception de délai d'attente d'interruption du thread Java (InterruptedTimeoutException) et fournit des exemples de code pertinents.

1. Analyse des causes du délai d'attente d'interruption :
L'opération d'interruption de thread est généralement une opération asynchrone, c'est-à-dire que l'indicateur d'interruption de thread est immédiatement défini sur true, mais il n'entraîne pas immédiatement l'arrêt de l'exécution du thread. La réussite de l'interruption du thread dépend de la conception du thread lui-même et de l'état d'exécution actuel. Lorsque vous devez interrompre un thread et attendre qu'il s'arrête dans un certain laps de temps, si le thread ne parvient pas à arrêter l'exécution dans le délai spécifié, une exception de délai d'attente d'interruption (InterruptedTimeoutException) sera levée.

2. Solution :
Les principales méthodes pour résoudre l'exception de délai d'attente d'interruption du thread Java sont les suivantes :

1. Utilisez la méthode Thread.join (long timeout) :
   Vous pouvez utiliser la méthode join (long timeout) du Thread. classe pour attendre le fil. Une fois que le thread appelant a exécuté cette méthode, il attend la fin du thread appelé ou que le délai d'attente spécifié soit atteint. Si le thread se termine dans le délai d'attente, il renverra vrai, sinon il renverra faux. Grâce à cette méthode, la situation d'expiration du délai d'interruption du thread peut être résolue efficacement.

L'exemple de code est le suivant :

Thread thread = new Thread(() -> {
    // 线程执行的逻辑代码
});

thread.start(); // 启动线程

try {
    thread.join(1000); // 线程最多等待1秒钟
} catch (InterruptedException e) {
    // 处理中断异常
}

if (thread.isAlive()) {
    thread.interrupt(); // 如果线程还未结束，手动中断
}

2. Utilisez la méthode Future.get (long timeout, TimeUnit unit) :
   Une autre solution consiste à utiliser Future et ExecutorService de la bibliothèque de concurrence Java. L'interface Future représente le résultat d'un calcul asynchrone et la méthode get(long timeout, TimeUnit unit) peut définir le délai d'attente. Si la tâche ne parvient pas à se terminer dans le délai d'expiration spécifié, une exception de délai d'attente sera levée, interrompant ainsi l'opération.

L'exemple de code est le suivant :

ExecutorService executor = Executors.newSingleThreadExecutor();

Future<?> future = executor.submit(() -> {
    // 线程执行的逻辑代码
    // 注意，此处不能使用while循环等待线程中断，否则可能导致线程无法正确中断
});

try {
    future.get(1000, TimeUnit.MILLISECONDS); // 最多等待1秒钟
} catch (InterruptedException | ExecutionException | TimeoutException e) {
    // 处理中断异常
    future.cancel(true); // 如果超时，手动取消任务
}

executor.shutdown(); // 关闭线程池

3. Drapeau d'interruption personnalisé et mécanisme de délai d'attente :
   Dans certains cas particuliers, il peut être nécessaire de personnaliser l'indicateur d'interruption et le mécanisme de délai d'attente. Vous pouvez utiliser des variables de type booléen modifié par volatilité comme indicateurs d'interruption, puis interroger pour déterminer l'indicateur pendant l'exécution du thread et interrompre manuellement le thread lorsque la condition de délai d'attente est remplie.

L'exemple de code est le suivant :

volatile boolean interrupted = false;

Thread thread = new Thread(() -> {
    while (!interrupted) {
        // 线程执行的逻辑代码
    }
});

thread.start(); // 启动线程

try {
    Thread.sleep(1000); // 等待1秒钟
} catch (InterruptedException e) {
    // 处理中断异常
}

interrupted = true; // 设置中断标志

thread.interrupt(); // 中断线程

Résumé :
Les trois méthodes courantes ci-dessus permettent de résoudre l'exception de délai d'attente d'interruption du thread Java (InterruptedTimeoutException). En utilisant la méthode Thread.join(), la méthode Future.get() ou un indicateur d'interruption personnalisé et un mécanisme de délai d'attente, nous pouvons éviter les exceptions causées par le délai d'attente de l'opération d'interruption de thread et implémenter des interruptions de thread flexibles et fiables.

Cependant, lors de l'utilisation d'opérations d'interruption de thread, nous devons également veiller à éviter les problèmes de concurrence tels que les blocages et les conditions de concurrence afin de garantir un fonctionnement sûr et fiable des threads.

Documents de référence :

1. Documentation officielle d'Oracle - https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html
2. Documentation officielle d'Oracle - https://docs.oracle .com/javase/8/docs/api/java/util/concurrent/Future.html

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!