Optimisation des Threads (comparaison de fragments d'ADN)

Bonjour à tout le monde !

J'ai un petit soucis que je n'arrive pas à résoudre.. J'espère que vous pourrez m'aider !

Je vous explique mon projet :

J'ai une liste de 1617 fragments dans un fichier .fasta et je dois comparer chaque paire de fragment entre eux (de manière normale et inversée/complémentaire)

Exemple :

Fragment 1 : ACTGCA Fragment 1 inversé/complémentaire : TGCAGT
Fragment 2 : TTGGCCGG Fragment 2 inversé/complémentaire : CCGGCCAA
Fragment 3 : GCGCTATA Fragment 3 inversé/complémentaire : TATAGCGC
Fragment 4 : CCAA Fragment 4 inversé/complémentaire : TTGG

Je dois donc aligner :

- le fragment 1 avec le fragment 2
- le fragment 1 avec le fragment 3
- le fragment 1 avec le fragment 4
- le fragment 2 avec le fragment 3
- le fragment 2 avec le fragment 4
- le fragment 3 avec le fragment 4
- le fragment 1 inversé/complémentaire avec le fragment 2
- le fragment 1 inversé/complémentaire avec le fragment 3
- le fragment 1 inversé/complémentaire avec le fragment 4
- le fragment 2 inversé/complémentaire avec le fragment 3
- le fragment 2 inversé/complémentaire avec le fragment 4
- le fragment 3 inversé/complémentaire avec le fragment 4

=> Pour un fichier de taille n, je devrais donc faire (n-1!)*2 comparaisons (ici 3! * 2 = 12)

Le soucis :

Dans mon cas j'ai un fichier avec 1617 fragments.. Ce qui veut dire que j'ai un très grand nombre de comparaisons à faire !!
J'aimerais savoir quelle manière serait la plus rapide pour les comparer.. Faire du multi-threading ? Ne pas en faire ? Si oui, combien de threads pour 1617 fragments ?

J'ai déjà essayer de faire un thread pour chaque fragment (donc un thread fait deux comparaisons : une normale et une inversée/complémentaire) mais le programme a planté car trop de thread apparemment.. J'ai ensuite essayé de faire un thread pour deux fragments (donc un thread fait 4 comparaisons) mais même résultat, le programme a planté.

Ici je suis arrivé à faire 1 thread pour 4 fragments (donc un thread fait 8 comparaisons) ce qui ne donne plus d'erreurs mais qui prend trop de temps (+ de 3h pour faire toutes les comparaisons)..

Code :

// La méthode pour aligner (pas besoin de savoir ce qu'est l'objet alignement je pense
public void alignement(Fragment f) {
  alignements.add(new Alignement(nucleobases, f.getNucleobases()));
  alignementsInverses.add(new Alignement(inverses, f.getNucleobases()));
}

// Dans mon controlleur j'utilise cette méthode
Collection c = model.getCollection();

ExecutorService execute = Executors.newFixedThreadPool((int)Math.ceil((double)c.getFragments().size()/4));
List<Future<Integer>> lists = new ArrayList<>();
  
int i = 0;
int tour = c.getFragments().size()%4 == 0 ? c.getFragments().size()/4 : c.getFragments().size() / 4 + 1;
int cpt = 0;
while(cpt < tour) {
 if(c.getFragments().size() % 4 == 0 || cpt != tour - 1) {
  lists.add(execute.submit(new AlignementCallable(c.getFragments(), i, i + 2, false)));
 } else {
  lists.add(execute.submit(new AlignementCallable(c.getFragments(), i, i + c.getFragments().size() % 4, true)));   
 }
 i += 2;
 cpt++;
}

Remarque :

Le premier thread va aligner par exemple sur une liste de 10 fragments :
- Le fragment 1 avec tous les autres; (2, 3, 4, 5, 6, 7, 8, 9, 10)
- Le fragment 2 avec tous les autres; (3, 4, 5, 6, 7, 8, 9, 10)
- Le fragment 10 avec tous les autres; (aucun en fait puisque le 10 est le dernier)
- Le fragment 9 avec tous les autres; (10)

Le deuxième :
- Le fragment 3 avec tous les autres;
- Le fragment 4 avec tous les autres;
- Le fragment 8 avec tous les autres;
- Le fragment 7 avec tous les autres;

Le troisième :
- Le fragment 5 avec tous les autres;
- Le fragment 6 avec tous les autres;

// La méthode call de AlignementCallable
 @Override
 public Integer call() throws Exception {
  if(!milieu) {
   for(int i = debut;  i < debut + 2; i++) {
    Fragment f = fragments.get(i);
    for(int j = i + 1; j < fragments.size(); j++) {
     f.alignement(fragments.get(j));
    }
    
    f = fragments.get(fragments.size() - i - 1);
    for(int j = fragments.size() - i; j < fragments.size(); j++) {
     f.alignement(fragments.get(j));
    }
   }
  } else {
   for(int i = debut; i < fin; i++) {
    Fragment f = fragments.get(i);
    for(int j = i + 1; j < fragments.size(); j++) {
     f.alignement(fragments.get(j));
    }
   }
  }
  
  return 1;
 }

Remarque : J'ai décidé d'implémenté l'interface Callable car c'est le seul moyen que j'ai trouvé pour que mon controlleur sache lorsque tous les threads ont été terminés (avec ce morceau de code)

// pour vérifier que les threads sont tous finis
try {
 int sum = 0;
 for(Future<Integer> f : lists) {
  sum += f.get();
 }
   
 if(sum == tour) { // Voir ici 
         System.out.println("On a fini de faire l'alignement semi global de toutes les paires de fragments");
 }
} catch (InterruptedException | ExecutionException e) {
 e.printStackTrace();
}
  
 execute.shutdown();

Merci pour votre aide.. Si vous avez des idées pour que le programme compare les 1617 fragments plus vite n'hésitez pas !! :)