Discussion :

[hools31]

Bonjour, j'ai codé une fonction de recherche avec des mots clé qui cherche sur des documents insérés dans des répertoires et sous répoertoires. Le soucis c'est que ca prends beaucoup de temps et justement j'aimerai le réduire. J'ai lu un article sur les threads qui permettent d'optimiser le temps d'execution. Mais j'ai vraiment pas tout compris en ce qui concerne le fonctionnement et comment je l'insère dans ma recherche. :/

Pouvez vous m'aider à insérer ces Threads ?

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
package nf;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
 
import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.sax.BodyContentHandler;
import org.xml.sax.SAXException;
 
public class RechercherFichier {
 
	public static ArrayList<String> searchKeywordsInFiles(File currentDir, String ...query) {
		ArrayList<String> files = new ArrayList<String>();
		if(currentDir.exists() && currentDir.isDirectory()) {
			for(File file : currentDir.listFiles()) {
				if(file.isDirectory()) {
					files.addAll(searchKeywordsInFiles(file, query));
				} else if(file.isFile()) {
					if(checkKeywordsForFile(file, query)) {
						files.add(file.getAbsolutePath());
					}
				}
			}
		}
		return files;
	}
 
	private static boolean checkKeywordsForFile(File file, String... query) {
		return checkKeywordsInFileName(file, query) || checkKeywordsInsideFile(file, query);
	}
 
	private static boolean checkKeywordsInFileName(File file, String... query) {
		for(String keyword : query) {
			String fileName = file.getName().toLowerCase();
			if(keyword.length() > 0 && fileName.contains(keyword.toLowerCase())) {
				return true;
			}
		}
		return false;
	}
 
	private static boolean checkKeywordsInsideFile(File file, String... query) {
		String parsedText = "";
 
		InputStream stream = null;
		BodyContentHandler handler = new BodyContentHandler();
		AutoDetectParser parser = new AutoDetectParser();
		Metadata metadata = new Metadata();
		try {
			stream = new FileInputStream(file);
			parser.parse(stream, handler, metadata);
			parsedText = handler.toString().toLowerCase();
		} catch (IOException e) {
			//e.printStackTrace();
		} catch (SAXException e) {
			//e.printStackTrace();
		} catch (TikaException e) {
			//e.printStackTrace();
		} finally {
			if(stream != null)
				try {
					stream.close();
				} catch (IOException e) {
					//e.printStackTrace();
				}
		}
 
		for(String keyword : query) {
			if(keyword.length() > 0 && parsedText.contains(keyword.toLowerCase())) {
				return true;
			}
		}
 
		return false;
	}
 
}

A l'aide !!!


Merci de votre attention et de votre compréhension

Bien cordialement

[joel.drigo]

Salut,

Utiliser des threads ne te permettra pas d'optimiser quoique ce soit. Enfin pas plus que du monothread. En revanche, avec du multi-threads on peut envisager de paralléliser. Avec un Executor utilisant un pool de threads de nombre fixe, on peut paralléliser ce type de processus. Bémol, l'aspect qui ralentis le plus ton processus est l'accès physique au disque : en parallélisant, tu ne gagneras pas sur le temps dû à l'accès physique, mais tu risques même d'en perdre (par exemple, en déplacement de tête). On peut toutefois faire la collecte en monothread, et faire l'analyse en multithread. Au niveau de la parallélisation, on voit assez facilement qu'on peut faire une tâche qui traite juste le contenu d'un dossier, sur un seul niveau, chaque dossier trouvé donnant lieu à une nouvelle tâche.

En ce qui concerne l'optimisation du processus, tu peux déjà éviter de construire une liste à chaque appel récursif. En gros au lieu de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public List<Machin> chercherMachins(...) {
    final List<Machin> machins = new ArrayList<>();
    for( ... ) {
          machins.addAll(chercherMachins(...));
    }
    return marchins;
}

Tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
public List<Machin> chercherMachins(...) {
    final List<Machin> machins = new ArrayList<>();
    chercherMachins(machins, ...);
    return marchins;
}
private void chercherMachins(final List<Machin> machins, ...) { 
    for( ... ) {
         chercherMachins(machins,...);
    } 
}

Autre chose : au lieu de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
for(String keyword : query) {
			String fileName = file.getName().toLowerCase();
			if(keyword.length() > 0 && fileName.contains(keyword.toLowerCase())) {
				return true;
			}
		}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
final String fileName = file.getName().toLowerCase();			
for(String keyword : query) {
   if(keyword.length() > 0 && fileName.contains(keyword.toLowerCase())) {
	return true;
  }
}

Te fera gagner sur le temps d'exécution de file.getName().toLowerCase(). Peu, certes, surtout si tu n'as que peu de mots-clefs. Par contre, si tu appliques le même principe à

• passer tous tes mots-clefs une seule fois au début en minuscule
• à supprimer dès le début les mots vide

ça peut devenir intéressant sur des arborescences importantes.

Enfin, regarde du côté de Files.walkFileTree, pour parcourir une arborescence de fichiers, et de ForkJoinPool, pour paralléliser ce parcours.