Comment gérer l'exception d'interruption du délai d'attente du thread dans le développement Java

Comment gérer l'exception d'interruption du délai d'attente des threads dans le développement Java

Dans le développement Java, l'utilisation de threads est très courante, en particulier lorsqu'il s'agit de tâches simultanées. Cependant, les délais d'attente et les interruptions des threads peuvent causer certains problèmes, nous devons donc gérer ces exceptions avec précaution. Cet article explique comment gérer les délais d'attente des threads et les exceptions d'interruption dans le développement Java.

1. Délai d'attente du thread

1. Utilisez les méthodes d'attente et de notification d'Object

En Java, nous pouvons utiliser les méthodes d'attente et de notification de la classe Object pour réaliser l'attente et le réveil des threads. La méthode wait peut mettre le thread en état d'attente et la méthode notify peut réveiller le thread en attente.

Lorsque nous attendons la fin d'une tâche, nous pouvons utiliser la méthode d'attente pour définir le délai d'attente, c'est-à-dire que le fil se réveillera automatiquement après avoir attendu un certain temps. Par exemple :

synchronized (lock) {
    long startTime = System.currentTimeMillis();
    while (!task.isDone()) {
        lock.wait(timeout);
        if (System.currentTimeMillis() - startTime > timeout) {
            break; // 超时，跳出循环
        }
    }
}

En attendant, nous devons également vérifier si la tâche est terminée, et si elle est terminée, nous pouvons sortir de la boucle. Cela empêche les threads d'attendre indéfiniment.

2. Utilisation des interfaces Future et Callable

ExecutorService en Java fournit un moyen plus avancé de gérer les délais d'attente des threads. Nous pouvons utiliser la méthode submit pour soumettre une tâche Callable et renvoyer un objet Future.

Les objets futurs peuvent être utilisés pour obtenir les résultats d'exécution des tâches, et le délai d'attente peut être défini. Par exemple :

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // 执行任务
        return "Task result";
    }
});

try {
    String result = future.get(timeout, TimeUnit.MILLISECONDS);
    // 处理任务结果
} catch (InterruptedException | ExecutionException | TimeoutException e) {
    // 处理异常
} finally {
    executor.shutdown();
}

Lorsque vous utilisez la méthode future.get() pour obtenir les résultats d'une tâche, vous pouvez définir un délai d'attente. Si le temps défini est dépassé, une TimeoutException sera levée.

2. Interruption du fil

1. Utilisez la méthode d'interruption

Les threads Java fournissent la méthode d'interruption pour interrompre le fil. Cette méthode peut être appelée lorsque nous devons interrompre un thread.

Lorsque nous traitons d'interruptions de thread, nous pouvons utiliser la méthode isInterrupted de Thread pour vérifier si le thread est interrompu, puis le gérer en conséquence. Par exemple :

while (!Thread.currentThread().isInterrupted()) {
    // 执行任务
}

Dans la boucle, nous pouvons vérifier en permanence l'état d'interruption du thread et sortir de la boucle si le thread est interrompu.

2. Utilisation d'ExecutorService

Si nous utilisons ExecutorService pour gérer le pool de threads, nous pouvons utiliser la méthode shutdownNow pour interrompre la tâche en cours d'exécution et renvoyer une liste des tâches inachevées. Par exemple :

ExecutorService executor = Executors.newSingleThreadExecutor();
executor.execute(new Runnable() {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // 执行任务
        }
    }
});

List<Runnable> unfinishedTasks = executor.shutdownNow();

Après avoir appelé la méthode shutdownNow, toutes les tâches inachevées seront interrompues et une liste des tâches inachevées sera renvoyée.

Résumé :

Dans le développement Java, il est très important de gérer les délais d'attente des threads et les exceptions d'interruption. Nous pouvons utiliser les méthodes wait et notify d'Object, les interfaces Future et Callable, la méthode d'interruption du thread et ExecutorService pour gérer ces exceptions. Une gestion correcte des délais d'attente et des interruptions des threads peut garantir que nos programmes sont plus stables et plus fiables.

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!