Discussion :

[hycar33]

Bonjour ,

voici mon problème j'utilise une méthode public synchronized pour accéder à un buffer , dans mon programme cette méthode est appelée de très nombreuses fois .
Ces appels à répétition provoquent une augmentation du nombre de thread et la saturation de la mémoire car le gargage collector n 'arrive plus à libérer de la mémoire trop d'appels dans la secodne
Comment je peux ré-écrire cette méthode pour éviter un verrou sur les threads et une libération plus rapide de la mémoire .
Merci de votre aide

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
private Buffer content = new Buffer();
 
public synchronized String getRow(final long lPosition) throws ApplicationPException {
        String sRow = content.get(lPosition);
		if (sRow == null) {
			sRow = "";
			long lLinePosition = 0;
		    if (lPosition != 1) {
		        if (lIndexLength != 0) {
		            lLinePosition = lIndexLength + 2 + (lPosition - 2)
		                    * (lLineLength + 2);
		        } else {
		            lLinePosition = (lPosition - 1) * (lLineLength + 2);
		        }
		    }
		    try {
		        this.seek(lLinePosition);
		        sRow = readLine();		       
		    } catch (Exception eException) {
		        throw new ApplicationException(ApplicationException.ERREUR_ACCES_BASE,
		                "Erreur lors de la récupération du la ligne n°"
		                        + lLinePosition + " du fichier '" + this.sFilePath
		                        + "'");
		    }
		    if(!sFilePath.startsWith("APP")){
				content.put(lPosition, sRow);
			}
		}
 
        return sRow;
    }

[joel.drigo]

Salut,

1. Ce n'est pas forcément le fait que la méthode soit synchronized qui augmente le nombre de threads, mais le fait qu'il y a plusieurs threads, à priori de plus en plus. La synchronisation peut contribuer à l'augmentation du nombre de threads en attente :
   
   1. par le temps d'exécution de la méthode. forcément plus elle est longue, plus les threads qui vont l'appeler vont attendre que le thread en cours d'exécution de la méthode ait terminé
   2. la possibilité de deadlock : des threads s'attendent les uns les autres indéfiniement, provoquant l'accumulation des nouveaux qui appellent la méthode
2. Ce n'est pas forcément le fait que la méthode soit synchronized qui augmente la mémoire utilisée, mais les objets crées et non libérés tant que la méthode n'a fini d'être exécutés
3. Pour ce qui du garbage collector, il faut voir si on ne passe pas beaucoup de temps à créer plein d'objets (inutilement) dont la libération à un moment va provoquer un gargage collecting long.

Donc

1. il faudrait voir les méthodes appelées dans la méthode getRow(). Ceci pour voir si on peut limiter la création de nouvelles instances.
2. Ensuite il est possible de traiter plus finement le verrouillage pour limiter les temps d'attentes selon deux principes :
   
   1. ne verrouiller que les objets dont l'accès concurrent pose un problème
   2. ne verrouiller que les accès qui posent un problème de concurrence. Par exemple, on peut verrouiller en écriture, mais pas en lecture
   
   On peut le faire entre autres :
   
   1. en synchronisant sur des objets au lieu de synchroniser sur la méthode
   2. en utilisant l'API java.util.concurrent.locks
   3. en utilisant des classes qui utilisent des mécanismes plus souples éventuellement, comme les java.util.concurrent.atomic.*, on une ConcurrentMap, etc.
   
   

[hycar33]

merci pour ton retour