Partager via


ThreadPoolExecutor.AfterExecute(IRunnable, Throwable) Méthode

Définition

Méthode appelée à la fin de l’exécution du Runnable donné.

[Android.Runtime.Register("afterExecute", "(Ljava/lang/Runnable;Ljava/lang/Throwable;)V", "GetAfterExecute_Ljava_lang_Runnable_Ljava_lang_Throwable_Handler")]
protected virtual void AfterExecute (Java.Lang.IRunnable? r, Java.Lang.Throwable? t);
[<Android.Runtime.Register("afterExecute", "(Ljava/lang/Runnable;Ljava/lang/Throwable;)V", "GetAfterExecute_Ljava_lang_Runnable_Ljava_lang_Throwable_Handler")>]
abstract member AfterExecute : Java.Lang.IRunnable * Java.Lang.Throwable -> unit
override this.AfterExecute : Java.Lang.IRunnable * Java.Lang.Throwable -> unit

Paramètres

r
IRunnable

runnable qui a terminé

t
Throwable

exception qui a provoqué l’arrêt ou null si l’exécution s’est terminée normalement

Attributs

Remarques

Méthode appelée à la fin de l’exécution du Runnable donné. Cette méthode est appelée par le thread qui a exécuté la tâche. Si la valeur n’est pas null, l’objet Throwable est l’inutilisable RuntimeException ou Error qui a provoqué l’arrêt brusque de l’exécution.

Cette implémentation ne fait rien, mais peut être personnalisée dans les sous-classes. Remarque : Pour imbriquer correctement plusieurs substitutions, les sous-classes doivent généralement appeler super.afterExecute au début de cette méthode.

<b>Remarque :</b> Lorsque les actions sont placées entre des tâches (telles que FutureTask) explicitement ou via des méthodes telles que submit, ces objets de tâche interceptent et gèrent les exceptions de calcul, et qu’ils ne provoquent donc pas d’arrêt brusque, et que les exceptions internes ne sont pas<> transmises <>à cette méthode. Si vous souhaitez intercepter les deux types d’échecs dans cette méthode, vous pouvez rechercher davantage de cas, comme dans cet exemple de sous-classe qui imprime la cause directe ou l’exception sous-jacente si une tâche a été abandonnée :

{@code
            class ExtendedExecutor extends ThreadPoolExecutor {
              // ...
              protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);
                if (t == null
                    && r instanceof Future<?>
                    && ((Future<?>)r).isDone()) {
                  try {
                    Object result = ((Future<?>) r).get();
                  } catch (CancellationException ce) {
                    t = ce;
                  } catch (ExecutionException ee) {
                    t = ee.getCause();
                  } catch (InterruptedException ie) {
                    // ignore/reset
                    Thread.currentThread().interrupt();
                  }
                }
                if (t != null)
                  System.out.println(t);
              }
            }}

Documentation Java pour java.util.concurrent.ThreadPoolExecutor.afterExecute(java.lang.Runnable, java.lang.Throwable).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

S’applique à