Discussion :

[Cvanhove]

Bonjour,

Je cherche à faire des extractions de données. Pour cela, je lance environ 10 Threads simultanément sur simple clique d'un btn. L'extraction se passe très bien, les Threads n'ont aucun soucis. Cependant si pendant ma première extraction (mes 10 Threads) je viens à recliquer sur mon btn extraction pour en lancer une deuxième, ça fait planter ma première extraction et la deuxième également.
Y a t il un paramétrage des Threads pour cela ou dois-je griser mon btn d'extraction une fois la première extraction lancée?

Cordialement

[Logan Mauzaize]

D'après mes tests, la plupart des applications peuvent créer entre 1000 et 3000 threads.

Est-ce que tu posterais pas plutôt un extrait minimaliste mais suffisamment complet de ton code ? Ainsi que la trace de l'erreur générée ?

[Cvanhove]

Extrait de code (j'espère que ça suffit ^^')

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
public class TaskExtractorService {
 
	private static final Logger LOGGER = LoggerFactory.getLogger(TaskExtractorService.class);
 
 
	public TaskExtractorService() {
		super();
	}
 
	private Boolean avancementThreads;
 
	public Boolean etatThreads(){
		return avancementThreads;
	}
 
	public String executeJob(final EntrepriseRequestData requetePoste, Client esClient, EntrepriseRequestProperties mRequestProperties, String path) throws InterruptedException {
 
		String data ="{}";
 
		EntrepriseRejectedExecutionHandler rejectionHandler = new EntrepriseRejectedExecutionHandler();
        //Get the ThreadFactory implementation to use
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        //creating the ThreadPoolExecutor
        ThreadPoolExecutor executorPool = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), 10, 100, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1024), threadFactory, rejectionHandler);
        //start the monitoring thread        
    	Map<String, Object> dataPostMap = requetePoste.getRequetesPoster();
 
        int nbreTotalPage  = Integer.valueOf(String.valueOf(dataPostMap.get(RequestHelper.NBRE_PAGE))) ; 
        int pageSize = Integer.valueOf(String.valueOf(dataPostMap.get(RequestHelper.PAGE_SIZE))) ;
        //submit work to the thread pool
        List<String> lstItem = new ArrayList<String>(nbreTotalPage);
        for(int i=1; i<nbreTotalPage+1; i++){
        	EntrepriseWorkerTask uneTask = new EntrepriseWorkerTask("iteration " +i ,esClient,requetePoste, mRequestProperties, i, pageSize,path,lstItem);
        	executorPool.submit(uneTask);
        }        
 
         try{             
     		ObjectMapper mapper = new ObjectMapper();
            executorPool.shutdown();
 
			data = mapper.writeValueAsString(lstItem);
 
			if(LOGGER.isDebugEnabled()){
			}
 
		} catch (JsonGenerationException e) {
			if(LOGGER.isErrorEnabled()){
				LOGGER.error("Erreur de serialisation ", e );
			}
		} catch (JsonMappingException e) {
			if(LOGGER.isErrorEnabled()){
				LOGGER.error("Erreur de serialisation ", e );
			}		
		} catch (IOException e) {
			if(LOGGER.isErrorEnabled()){
				LOGGER.error("Erreur de serialisation ", e );
			}
		} 
        return data;
	}
 
}

Hélas pour l'erreur, la console est trop bavarde je n'arrive pas à la retrouver, mais il me semble avoir vu passer un OutOfMemory mais sans grande conviction.

[joel.drigo]

Salut,

Hélas pour l'erreur, la console est trop bavarde je n'arrive pas à la retrouver, mais il me semble avoir vu passer un OutOfMemory mais sans grande conviction.

On voit dans ton code une référence à un Logger. Un petit coup d'éditeur/tail/autre sur le fichier de log avec un éditeur de texte devrait de permettre de voir les erreurs, si tant est qu'elles soient également bien loguées dans les tâches soumises à l'executor... et, sinon, une console, ça peut se rediriger vers un fichier aussi, éventuellement.

[Logan Mauzaize]

Si tu as un OutOfMemory, c'est que ton traitement est trop gourmand pour la capacité de ton application :

• Soit limiter la consommation mémoire de chaque tâche
• Soit limiter le nombre de tâches
• Soit augmenter la capacité mémoire de ton application

Pour limiter le nombre de tâches en parallèle, il existe les ExecutorService. Cependant, il n'y a pas d'intérêt à les créer/détruire pour chaque requête de traitement. Si tu veux soumettre une liste de tâche et attendre la fin de leurs exécutions, il existe invokeAll.

L'utilisation de l'API Fork/Join (Voir "Fork/Join - diviser pour mieux régner", par F. Martini) me semblerait plus adapté dans ton cas. Le principe consiste à diviser une tâche si elle est trop grande pour être traitée séquentiellement. De manière préférentielle, les sous-tâches sont exécutées par le même thread mais peuvent éventuellement être "volées" par d'autres thread inoccupés du pool.


Pour augmenter la capacité mémoire de ton application, il faut utiliser (par exemple) l'option "-Xmx" de ta machine virtuelle (" Les options pour configurer le ramasse-miettes", par JM. Doudoux).


Pour limiter la consommation mémoire de chaque tâche, c'est un travail de longue haleine mais en général ca passe par l'aggrégation de données à la source (ex: requête SQL), le traitement par flux (plutôt que tout chargé en mémoire), l'utilisation de cache à débordement (ce qui ne tient pas en mémoire est écrit sur disque), etc.