Discussion :

[raspac]

Bonjour,
J'ai un problème au niveau de la gestion d'un thread.
Dans mon code, j'ai une classe (non thread elle-même) qui créé et lance un thread. Cette classe envoie des données que le thread doit copier dans un fichier.
Seulement, le thread n'arrive pas tout le temps à la fin de son traitement, il reste dans sa boucle infinie.

La boucle du thread est conditionnée par un booléan à vrai au lancement. Je le mets à faux quand il n'y a plus de données à envoyer.

Dans le cas où le thread se termine, il n'y a pas de problème, toutes les données sont copiées dans le fichier.
Dans l'autre, la chaîne que le thread doit copier n'est pas complète, elle est tronquée. Et je ne sais pas pourquoi.


Voici la classe principale, j'ai supprimé le superflu :

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

public class GenetiqueCube 
{
	// matrice binaire décrivant le cube
	private int[][][] matriceCube;
	// Thread pour sauvegarder le fichier	
	private SaveFicThread myThread; 
	
	
	public void affinage()
	{
		try 
		{
			myThread = new SaveFicThread();
			myThread.start();
		}
		catch(IOException e)
		{ e.printStackTrace(); }
		
		
		for(int i = 1; nbEssaiTmp > 0; i++)
		{
			try 
			{
				String generation = Outils.matriceToString();
				myThread.addGeneration(generation);					 
			}
			catch(Exception e) {}
		}


		try {
		myThread.setEcritureOK(false); }

		catch(Exception e) { e.printStackTrace();
		}
	}
}

Et voici mon thread :

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
 
public class SaveFicThread extends Thread
{
	// flag pour continuer ou pas l'écriture
	private boolean ecritureOK;
	// fichier on on écrit
	private FileWriter writerMatrice;
        // queue
	private LinkedList<String> queue;
 
	public SaveFicThread() throws IOException
	{
		queue = new LinkedList<String>();
		writerMatrice = new FileWriter(ficMatrice, false);
		ecritureOK = true;
	}
 
	// Ecriture des générations dans le fichier
	public void run()
	{
		boolean continuer = true;
		while(continuer)
		{
			try
			{
				synchronized(this)
				{
					String generation = getGeneration() + "\n";
					writerMatrice.write(generation, 0, generation.length());
					continuer = ecritureOK;
				}
			}
			catch(InterruptedException e)
			{ e.printStackTrace(); }
			catch(IOException e)
			{ e.printStackTrace(); }
 
		}
		try {
		writerMatrice.close(); }
 
		catch(IOException e)
		{ e.printStackTrace(); }
	}
 
 
	// Ajout d'une génération dans la queue
	public synchronized void addGeneration(String gen)
	{
		queue.addLast(gen);
		notify();
	}
 
	// Retrait d'une génération
	public synchronized String getGeneration() throws InterruptedException
	{
		while(queue.isEmpty())
		{
			wait();
		}
		return queue.removeFirst();
	}
 
 
	public synchronized void setEcritureOK(boolean b)
	{ ecritureOK = b; }
}

Merci beaucoup d'avance

[Djobird]

Essaye en rajoutant dans la fonction setEcritureOK(bool); un notify.
Car là, il est possible que lorsque ton main appelle cette fonction à la fin, que le thread soit déjà endormis.

[raspac]

Ça ne marche pas mieux.
Merci

[adiGuba]

Salut,

Salut,

+1 pour le notify() dans setContinuer(), mais il faudrait également que getGeneration() gère ce cas de sortie !!!



Sinon j'ai quelques remarques sur ton code :

• La gestion de tes exceptions n'est ps très clair (plein de try/catch). Difficile de savoir ce qu'il va se passer lors d'une exception...
• Synchronisation "lourde". Ton thread prend le verrou pendant toutes l'écriture, et bloquera donc potentiellement les autres thread. La synchro autour de ecritureOK est assez lourde alors qu'il suffirait de définir la variable en volatile (c'est même mieux d'ailleurs).
• Il serait préférable d'ouvrir le fichier dans la méthode run() et non pas dans le constructeur, et d'utiliser un try/finally pour le fermer. La gestion du fichier en sera plus clair et plus sûr !
• Pourquoi ne pas utiliser une BlockingQueue ????

a++

[raspac]

Bonjour,
merci beaucoup à vous deux, ça marche parfaitement maintenant.
Et merci pour les remarques, je vais en tenir compte.