Comment faire pour exécuter les différentes méthodes de rapprochement

J'ai une méthode java qui contient 5 différentes méthodes internes. Pour l'amélioration de la performance, je tiens à appeler ces méthodes parallèle.

par exemple exécuter method1, method2, ... method5 parallèle à l'aide de fil.

private void getInformation() throws SQLException,
            ClassNotFoundException, NamingException {
    method1();
    method2();
    method3();
    method4();
    method5();
}

mais tous ces 5 méthodes différentes de la logique métier.

L'exécution de chaque méthode, en vertu de son propre thread en supposant qu'ils ne partagent aucune mutable état ?
Merci pour cette réponse, pourriez-vous préciser ou donner un exemple de lien 🙂
Ici, vous allez - vogella.com/articles/JavaConcurrency/article.html
Depuis que vous avez identifié que vous avez besoin de threads, ce qui est exactement votre question? Comment pouvez-vous invoquer de nouveaux threads?
oui...parce que ceux-ci sont différents de la logique métier. et je ne sais pas comment appeler les fils de cette

OriginalL'auteur user1037452 | 2013-08-10

  1. 14

    Faire quelque chose comme ceci:

    1. Pour chaque méthode, créer un objet Appelable qui encapsule cette méthode.
    2. Créer un Exécuteur testamentaire (fixe pool de threads exécuteur testamentaire doit être fine).
    3. Mettre tous vos Callables dans une liste et de les invoquer à l'Exécuteur testamentaire.

    Voici un exemple simple:

    public void testThread()
{

   //create a callable for each method
   Callable<Void> callable1 = new Callable<Void>()
   {
      @Override
      public Void call() throws Exception
      {
         method1();
         return null;
      }
   };

   Callable<Void> callable2 = new Callable<Void>()
   {
      @Override
      public Void call() throws Exception
      {
         method2();
         return null;
      }
   };

   Callable<Void> callable3 = new Callable<Void>()
   {
      @Override
      public Void call() throws Exception
      {
         method3();
         return null;
      }
   };

   //add to a list
   List<Callable<Void>> taskList = new ArrayList<Callable<Void>>();
   taskList.add(callable1);
   taskList.add(callable2);
   taskList.add(callable3);

   //create a pool executor with 3 threads
   ExecutorService executor = Executors.newFixedThreadPool(3);

   try
   {
      //start the threads and wait for them to finish
      executor.invokeAll(taskList);
   }
   catch (InterruptedException ie)
   {
      //do something if you care about interruption;
   }

}

private void method1()
{
   System.out.println("method1");
}

private void method2()
{
   System.out.println("method2");
}

private void method3()
{
   System.out.println("method3");
}

    Assurez-vous que chaque méthode ne permet pas de partager l'état (comme sur un champ mutable dans la même classe) ou vous pouvez obtenir des résultats inattendus. Oracle fournit une bonne introduction à Java Exécuteurs. Aussi, ce livre est génial si vous faites n'importe quel type de filetage en java.

    Tout est super et tout, sauf que rien passé List<Future<Void>> futureList = executor.invokeAll(taskList); sera exécuté, de sorte que ces minuteries ne fonctionnent pas.
    Oui, vous avez raison. J'ai mis à jour l'exemple.

    OriginalL'auteur lreeder

  2. 3

    Pour exécuter method1 en parallèle, effectuer les opérations suivantes:

    Thread t1=new Thread() {
   public void run() {
       method1();
   }
};
t1.start();

    Le faire pour toutes vos méthodes.

    Attendre method1 pour finir, ne 

    t1.join();

    et ainsi de suite pour tous les autres threads.

    Beaucoup de gens vont vous dire utilisation de pool de threads et ne s'étendent pas au Fil - tout cela a peu de sens pour vous, juste maintenant. La maîtrise de cette manière, et seulement de suivre ensuite des conseils.

    vous n'êtes pas à répondre à la question.

    OriginalL'auteur Alexei Kaigorodov

  3. 0

    Vous pouvez utiliser le haut niveau de la simultanéité de l'instrument en Java pool de threads. Mais de toute façon, vous aurez à créer des Exécutables, des objets (des tâches), puis l'utilisation du pool de threads de la méthode - invokeAll(). Veuillez prendre un coup d'oeil à Oracle de la simultanéité tutoriel

    mais tous ces 5 méthodes différentes de la logique métier
    Alors, quel est le problème avec l'aide de pool de threads et "différent de la logique métier"? Je ne comprends pas tout vos doutes. Mais il semble que vous avez besoin de lire des informations de base sur la simultanéité des trucs en java

    OriginalL'auteur XZen

  4. 0

    prendre un coup d'oeil à java.util.simultanées
    http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/package-summary.html
    et le tutoriel:
    http://docs.oracle.com/javase/tutorial/essential/concurrency/
    fondamentalement, vous devez créer un executorserice, une classe étendant Praticable, et de les invoquer

    OriginalL'auteur jlb

  5. 0

    Vous devez utiliser 5 différents threads pour exécuter vos méthodes en parallèle, le code, il n'est pas difficile mais assez ennuyeux.

    Vous voudrez peut-être avoir un coup d'oeil à Gpars Tâches, qui font de l'écriture de code parallèle beaucoup plus facile et agréable.

    http://gpars.org/1.0.0/guide/guide/dataflow.html#dataflow_tasks

    OriginalL'auteur pditommaso