Java: Exécutable paramétrable

Standard Runnable interface a seulement non paramétrées run() méthode. Il est également Callable<V> interface avec call() méthode retournant le résultat de type générique. J'ai besoin de passer de paramètre générique, quelque chose comme ceci:

interface MyRunnable<E> {
  public abstract void run(E reference);
}

Est-il une interface standard pour cette fin ou je dois déclarer que, de base, un par moi-même?

source d'informationauteur mschayna

  1. 13

    En général, vous mettre en œuvre Runnable ou Callable en tant que classe, qui a soutenu une genertic paramètre d'entrée; par exemple,

    public class MyRunnable<T> implements Runnable {
  private final T t;

  public MyRunnable(T t) {
    this.t = t;
  }

  public void run() {
    //Reference t.
  }
}
  2. 9

    Il est également com.google.commun.de la base.Fonction<F, T> de Google CollectionsGoyave.

    Si vous définissez le type de sortie à ? ou Void (et l'avoir toujours revenir null), vous pouvez l'utiliser comme une alternative à Runnable avec un paramètre d'entrée.

    Cela a l'avantage d'être en mesure d'utiliser Functions.compose pour transformer la valeur d'entrée, Iterables.transform à appliquer à chaque élément d'une collection etc.

  3. 8

    Java 8 comprend les java.util.fonction.Consommation<T> interface avec le seul non-méthode par défaut void accept(T t).

    Il existe de nombreuses autres interfaces dans ce package.

  4. 3

    En général, si vous voulez passer un paramètre dans le run() méthode, vous aurez la sous-classe Runnable avec un constructeur qui prend un paramètre.

    Par exemple, Vous voulez faire:

    //code
Runnable r = new YourRunnable();
r.run(someParam);
//more code

    Vous avez besoin pour ce faire:

    //code
Runnable r = new YourRunnable(someParam);
r.run();
//more code

    Vous permettra de mettre en œuvre YourRunnable similaire à ci-dessous:

    public class YourRunnable implements Runnable {
    Some param;
    public YourRunnable(Some param){
        this.param = param;
    }
    public void run(){
        //do something with param
    }
}
  5. 0

    Je suggère de définir une interface comme le fait dans la question d'origine. En outre, éviter de typage faible par rendre l'interface spécifique pour ce qu'il est censé faire, plutôt que d'un sens sans interface comme Runnable.

  6. -3

    Exécutable n'est pas destiné à être appelé directement par le code du client comme foo.run() qui seraient exécutées de manière séquentielle dans le thread courant.

    De la Praticable API:

    L'interface Runnable devrait être
    mis en œuvre par toute la classe dont
    les instances sont destinés à être exécuté
    par un thread. La classe doit définir un
    méthode de n arguments appelé run.

    Cette interface est conçu pour fournir
    un protocole commun pour les objets
    souhaitez exécuter du code lorsqu'ils sont
    active. Par exemple, l'Exécutable est
    mis en œuvre par la classe Thread. Être
    actif signifie simplement qu'un thread a
    été commencé et n'a pas encore été
    arrêté.

    En outre, Exécutable fournit l'
    les moyens d'une classe à être actif tout en
    pas de sous-classement Thread. Une classe qui
    implements Runnable peut fonctionner sans
    sous-classement Thread par l'instanciation d'un
    Thread instance et en passant lui-même dans
    en tant que cible. Dans la plupart des cas, la
    Praticable de l'interface doit être utilisé si
    vous êtes seulement de planification pour remplacer la
    méthode run() et aucun autre Thread
    des méthodes. Ceci est important parce que
    les classes ne doivent pas être sous-classé
    à moins que le programmeur a l'intention de
    la modification ou de l'amélioration de la fondamentale
    le comportement de la classe.

    Au lieu de cela, vous créez un nouveau Thread instance en fonction de votre exécutable, et ensuite appeler bar.start(). C'est alors la JVM de la responsabilité de faire appel run() dans ce thread séparé.

    Exemple:

     public class Foo<E> implements Runnable {
     private final E e;
     public Foo(E e) { ... }
     @Override
     public void run() {
         do something with e.
     }
 }

 Foo<String> foo = new Foo("hello");
 Thread bar = new Thread(foo);
 bar.start();