Discussion :

[Arsenic68]

J'ai deux threads dans mon application, le général qui va s'occuper de l'interface graphique et des événements associés et un thread qui va lire un très gros fichier.

Toutes les secondes (je vais augmenté ça plus tard), l'interface graphique mets à jour ses champs en fonction de ce qu'a lu l'autre thread. Le problème c'est qu'au bout d'un moment, le thread producteur ajoute un élément dans une liste que le lecteur est entrain de traiter. Comment faire pour ne pas soulever ce problème.

Le lecteur

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private void raffraichirAffichage(){
...
        int index = 0;
	listView.BeginUpdate();
	listView.Items.Clear();
	foreach (Toon t in l.getListeToon()) {
		listView.Items.Add(t.Nom);
		if (t.Nom.Equals(nomSelectione)) {
			listView.Items[index].Selected = true;
		}
		index++;
	}
	listView.EndUpdate();
}

Le producteur

Code :

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

1
2
3
4
5
6
7
8
 
...
	agresseur = this.getListeToon().Find(Toon => Toon.Nom.Equals(nomAgresseur));
	if (agresseur == null) {
		agresseur = new Toon(nomAgresseur);
		this.getListeToon().Add(agresseur);
	}
...

Code :

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

1
2
3
4
5
6
7
public ToonListe getListeToon() {
	ToonListe ret = null;
	lock (this.listeToon) {
		ret = this.listeToon;
	}
	return ret;
}

Avec la méthode comme ça, le problème a lieu beaucoup plus tôt, comme si je perdais tous les avantages des threads

Merci d'avance

[bacelar]

Je pense que lock est la bonne solution, mais il faut correctement l'appliquer.
Donc le Lock doit entourer l'utilisation de la structure partagé et non l'accesseur à celui-ci.

Le lecteur doit, lui aussi utiliser lock.

Code :

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

1
2
3
4
5
6
7
8
9
 
ToonListe toto = l.getListeToon();
lock(toto)
{
	foreach (Toon t in toto ) {
		....	
		index++;
	}
}

Il faudrait réduire au maximum la contention sur la structure, donc ne pas utiliser les propriétés des contrôles mais remplir des structures type liste de string pour les utiliser après la lecture et donc réduire aussi le temps de verrouillage de la structure.

Pour le producteur :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
ToonListe toto = l.getListeToon();
lock(toto)
{
	agresseur = toto.Find(Toon => Toon.Nom.Equals(nomAgresseur));
	if (agresseur == null) {
		agresseur = new Toon(nomAgresseur);
		toto.Add(agresseur);
	}
}

Même chose que pour le code du consommateur, limitez les actions au minimum durant l'écriture, mais si vous avez besoin de cohérence dans la structure, ne libérez la structure que lorsque vous avez fini toutes les actions nécessaire à cette cohérence.
Dans l'exemple, on se sert du contenu de la liste pour faire un choix sur ajouter ou non un élément, si cette condition ne doit pas varier entre la lecture de la liste et l'ajout, il faut garder le lock.

Il faut d’abord avoir une solution correcte fonctionnellement avant de l'optimiser.

[Arsenic68]

ta méthode marche très bien, le problème c'est que j'ai doublé le temps avec le lock (enfin pas tout a fait vu que je diminue le nombre d'affichage qui doit prendre du temps).

Bon, il faudrait que j'affine le temps de refresh, ça me permettra le "perdre" moins de temps

[bacelar]

Comme je l'ai déjà indiqué, sortez tous les affichages de la boucle de lecture de la structure partagée.