Comment diviser une énorme boucle en plusieurs threads, puis ajouter le résultat à la collecte?

Question

J'effectue une tâche dans une boucle. Je dois diviser cette boucle de 1,2 million en plusieurs threads. Chaque thread aura un résultat dans la liste. Lorsque tous les threads sont terminés, j'ai besoin d'ajouter toutes les données de la liste des threads dans une liste commune. Je ne peux pas utiliser ExecutorService. Comment puis-je faire ceci?

Il devrait être compatible avec jdk 1.6.

C'est ce que je fais en ce moment:

List<Thread> threads = new ArrayList<Thread>(); 
int elements = 1200000; 

public void function1() { 

     int oneTheadElemCount = 10000; 
     float fnum_threads = (float)elements/(float)oneTheadElemCount ; 
     String s = String.valueOf(fnum_threads); 
     int num_threads = Integer.parseInt(s.substring(0, s.indexOf("."))) + 1 ; 

     for(int count =0 ; count < num_threads ; count++) { 
      int endIndex = ((oneTheadElemCount * (num_threads - count)) + 1000) ; 
      int startindex = endIndex - oneTheadElemCount ; 

      if(count == (num_threads-1)) 
      { 
       startindex = 0; 
      } 
      if(startindex == 0 && endIndex > elements) { 
       endIndex = elements -1 ; 
      } 

      dothis(startindex,endIndex); 
     } 

     for(Thread t : threads) { 
      t.run(); 
     } 
    } 

public List dothis(int startindex, int endIndex) throws Exception { 
    Thread thread = new Thread(new Runnable() { 
     @Override 
     public void run() { 
      for (int i = startindex; 
        (i < endIndex && (startindex < elements && elements)) ; i++) 
      { 
       //task adding elements in list  
      }     
     } 
    });   
    thread.start(); 
    threads.add(thread); 
    return list; 
} 

Answer 1

Je ne sais pas quelle version de Java que vous utilisez, mais en Java 7 et plus, vous pouvez utiliser la fourche/join ForkJoinPool.

Fondamentalement,

fourche/join, introduit en Java 7, ne vise pas à remplacer ou concurrencer avec les classes utilitaires existants concurrency; à la place, il met à jour et les complète. Fork/Join répond à la nécessité de diviser pour régner, ou un traitement des tâches récursif dans les programmes Java (voir Ressources).

La logique fork/join est très simple: (1) séparer (fork) chaque grande tâche en tâches plus petites; (2) traiter chaque tâche dans un fil séparé (en les séparant en tâches encore plus petites si nécessaire); (3) rejoindre les des résultats.

Citation. Il existe plusieurs example en ligne qui peuvent l'aider Je ne l'ai pas utilisé moi-même.

J'espère que cela aide.

---

Pour Java6, vous pouvez suivre related SO question.