Convertir plusieurs méthodes Java pour les exécuter en tant que threads non bloquants?

Question

Est-il possible de convertir un certain nombre de méthodes (définies dans une interface et implémentées dans une classe) pour qu'elles s'exécutent en tant que threads non bloquants?

Certainement, je peux emballer chaque méthode dans la méthode run() d'une classe de thread. Mais peut-être existe-t-il une manière plus sophistiquée de déformer plusieurs méthodes différentes en une seule étape, c'est-à-dire par un encapsuleur de classe de thread unique?

Selon l'exemple de « Adamski » ci-dessous, je ne veux pas créer une nouvelle classe Runnable pour chaque méthode de l'interface, par exemple je voudrais éviter:

public interface MyBusinessClass 
{ 
    void a(); 
    void b(); 
} 


public class MyRunnable_a implements Runnable 
{ 
    private final MyBusinessClass bizClass; 
    public MyRunnable_a(MyBusinessClass bizClass) { this.bizClass = bizClass; } 

    public void run() { bizClass.a(); } 
} 


public class MyRunnable_b implements Runnable 
{ 
    private final MyBusinessClass bizClass; 
    public MyRunnable_b(MyBusinessClass bizClass) { this.bizClass = bizClass; } 

    public void run() { bizClass.b(); } 
} 

Answer 1

Sur la base de votre question et commentaire ci-dessus, vous voulez l'invocation d'une méthode entraîner la performance asynchrone d'une tâche. La meilleure façon de le faire est via des instances de Runnable et un ExecutorService.

public class MyBusinessClass { 
    ExecutorService myExecutor = Executors.newCachedThreadPool(); //or whatever 

    void a(){ 
    myExecutor.execute(new Runnable() { 
     public void run() { 
      doA(); 
     } 
    }); 
    }  

    void b(){ 
    myExecutor.execute(new Runnable() { 
     public void run() { 
      doB(); 
     } 
    }); 
    }  
} 

penser de cette façon, afin d'exécuter de manière asynchrone, vous devez envoyer une sorte de message à un autre thread pour indiquer qu'il doit travailler. Le framework Executor dans le package java.util.concurrent est la manière standard de former ces messages. Ils sont formés de telle sorte que la méthode "run" de l'instance Runnable indique les actions à effectuer.

Answer 2

Plutôt que hériter de java.lang.Thread et remplacer la méthode run() il serait plus propre de créer une implémentation de java.lang.Runnable qui a appelé les méthodes dans l'ordre souhaité. L'implémentation Runnable pourrait avoir une référence à votre classe fournissant ces méthodes ou pourrait faire partie de la classe elle-même.

/** 
* Business class that defines the methods to be run in a dedicated thread. 
* Classes implementing this interface are responsible for thread safety. 
*/ 
public interface MyBusinessClass { 
    void a(); 

    void b(); 

    void c(); 
} 

/** 
* Runnable implementation that calls the methods defined on MyBusinessClass. 
*/ 
public class MyRunnable implements Runnable { 
    private final MyBusinessClass bizClass; 

    public MyRunnable(MyBusinessClass bizClass) { 
    this.bizClass = bizClass; 
    } 

    public void run() { 
    bizClass.a(); 
    bizClass.b(); 
    bizClass.c(); 
    } 
} 

Answer 3

Faites-les se conforment à l'interface appelable et leur fournir un convenable Exécuteur (beaucoup de choix dans Executors)