Lancer une Thread après la fin de deux autres

**Zarrows** · 08/02/2012, 15h37

Bonjours,

Un bout de code vaut mieux qu'une grande explication

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
private void Generation()
{
btnLancer.Enabled = false;
 
Workbook Wb1 = new Workbook(@txtbox1.Text);
Workbook Wb2 = new Workbook(@txtbox2.Text);
 
//Lecture Fichier 1 (Thread1)
Thread T_CollectionFichier1 = new Thread(=new ParameterizedThreadStart(CollectionFichier1));
T_CollectionFichier1.Start(Wb1)
 
//Lecture Fichier 2 (Thread2)
Thread T_CollectionFichier2 = new Thread(=new ParameterizedThreadStart(CollectionFichier2));
T_CollectionFichier1.Start(Wb2)
 
//Generation du FichierG (Thread 3)
Thread T_GenXLS = new Thread(new ThreadStart(GenXLS));
T_GenXLS.Start();
 
btnLancer.Enabled = true;
}

Je m'explique maintenant :

Le but est d'éxecuter mon thread3 apres que le thread1 et 2 sois terminé. J'ai déja fait des test avec le join en faisant :

Code :

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

T_GenXLS().Join();

mais il dit qu'il ne c'est pas éxécuter (normal vu que les deux permiers Thread son très long).

Merci d'avance

!

**BenoitM** · 08/02/2012, 15h43

Utilisez cette méthode pour vous assurer qu'un thread s'est arrêté. L'appelant sera indéfiniment bloqué si le thread ne s'arrête pas. Si le thread est déjà arrêté lorsque Join est appelé, le retour de la méthode est immédiat.

Cette méthode change l'état du thread appelant de manière à inclure ThreadState.WaitSleepJoin. Vous ne pouvez pas appeler Join sur un thread dont l'état est ThreadState.Unstarted.

Donc je vois pas d'ou peut venir le problème

Code :

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

1
2
3
4
5
6
7
 
//Main Thread attend que le Thread1 et 2 soit terminer
T_CollectionFichier1.Join();
T_CollectionFichier2.Join();
//Lancement du Thread3
Thread T_GenXLS = new Thread(new ThreadStart(GenXLS));
T_GenXLS.Start();

**Zarrows** · 08/02/2012, 15h51

Code :

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

1
2
3
4
5
6
//Main Thread attend que le Thread1 et 2 soit terminer
T_CollectionFichier1.Join();
T_CollectionFichier2.Join();
//Lancement du Thread3
Thread T_GenXLS = new Thread(new ThreadStart(GenXLS));
T_GenXLS.Start();

Merci ! Moi j'avait pas fait comme ça ! J'était partit sur :

Code :

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

1
2
3
4
5
6
7
//Main Thread attend que le Thread1 et 2 soit terminer
T_CollectionFichier1
T_CollectionFichier2
//Lancement du Thread3
Thread T_GenXLS = new Thread(new ThreadStart(GenXLS));
T_GenXKS.Join();
T_GenXLS.Start();

En pensant que l'appelant était l'objet qui utiliser la méthode .join().

Je test ça tout de suite.

**Bluedeep** · 08/02/2012, 17h46

Autre possibilité, utiliser directement les objets de synchro. Cela te permet éventuellement de démarrer le troisième, une fois que les deux premiers ont terminées les tâches utiles, sans pour autant avoir terminé le thread.

**Zarrows** · 09/02/2012, 11h29

Bon alors résultat : ça marche j'ai bien ce que je voulait, le problème c'est que ça bloque complétement ma form et mon invoke sur ma progress bar.

Est ce qu'il y aurait un moyen de démarrer la troisième thread avec un .IsAlive et un while ? J'ai l'idée mais pas la conception.

@BlueDeep

une fois que les deux premiers ont terminées les tâches utiles

Mes deux thread font qu'une tache utile

Mais si la synchro peut permettre a ma troisième thread de démarrer après les deux autre ça serait parfait.

**Bluedeep** · 09/02/2012, 11h32

Envoyé par Zarrows

Mes deux thread font qu'une tache utile

Mais si la synchro peut permettre a ma troisième thread de démarrer après les deux autre ça serait parfait.

Exemple (torché en 2mn, donc pas à prendre au pied de lettre, il est là juste pour te montre le principe du mécanisme) :

Ici, les deux premiers thread démarrent, le thread lanceur (le main ici) attend que les deux autres thread aient confirmé qu'il peut lancer le troisième, et continuent.

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
public class ThreadTest
{
	ManualResetEvent _event1;
	ManualResetEvent _event2;
	public ThreadTest(ManualResetEvent event1, ManualResetEvent event2)
	{
		_event1 = event1;
		_event2 = event2;
	}
	private void longLoop()
	{
		for (int i = 0; i < 200; i++)
		{
			Thread.Sleep(10);
		}
	}
	public void LongMethod1()
	{
		Console.WriteLine("LongMethod1 démarre");
		longLoop();
		_event1.Set(); // Thread sur LongMethod3 autorisé à démarré
		Console.WriteLine("LongMethod1 autorise LongMethod3 à démarrer");
		longLoop();
		Console.WriteLine("LongMethod1 termine");
	}
 
	public void LongMethod2()
	{
		Console.WriteLine("LongMethod2 démarre");
		longLoop();
		_event2.Set(); // Thread sur LongMethod3 autorisé à démarré
		Console.WriteLine("LongMethod2 autorise LongMethod3 à démarrer");
		longLoop();
		Console.WriteLine("LongMethod2 termine");
	}
	public void LongMethod3()
	{
		Console.WriteLine("LongMethod3 démarre");
		longLoop();
		Console.WriteLine("LongMethod3 termine");
	}
 
}
class Program
{
	static void Main(string[] args)
	{
		ManualResetEvent event1 = new ManualResetEvent(false);
		ManualResetEvent event2 = new ManualResetEvent(false);
 
		ThreadTest threadTest = new ThreadTest(event1, event2);			
		Thread thread1 = new Thread(new ThreadStart(threadTest.LongMethod1));
		Thread thread2 = new Thread(new ThreadStart(threadTest.LongMethod2));
		thread1.Start();
		thread2.Start();
		ManualResetEvent.WaitAll(new ManualResetEvent[] { event1, event2 });
		Thread thread3 = new Thread(new ThreadStart(threadTest.LongMethod3));
		thread3.Start();
		Console.ReadKey();
	}
}

**Zarrows** · 09/02/2012, 11h38

Et cela ne va pas bloquer ma main thread ?

**Bluedeep** · 09/02/2012, 11h43

Envoyé par Zarrows

Et cela ne va pas bloquer ma main thread ?

Ici, j'ai choisi que la main attendent que les deux seconaires se signalent.

Si je ne veux pas bloquer la "main", je peux mettre le mécanisme d'attente dans un autre thread qui se contente d'être l'ordonnanceur des trois autres.

**Bluedeep** · 09/02/2012, 11h49

Exemple modifé pour illuster ce que je te dis (ici, donc 5 threads : 1 main, 1 scheduler, et les 3 autres) , le main continuant à bosser (ici un écho clavier, suffisant pour la démo).

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
public class ThreadTest
{
	ManualResetEvent _event1;
	ManualResetEvent _event2;
	public ThreadTest(ManualResetEvent event1, ManualResetEvent event2)
	{
		_event1 = event1;
		_event2 = event2;
	}
	private void longLoop()
	{
		for (int i = 0; i < 1000; i++)
		{
			Thread.Sleep(10);
		}
	}
	public void LongMethod1()
	{
		Console.WriteLine("LongMethod1 démarre");
		longLoop();
		_event1.Set(); // Thread sur LongMethod3 autorisé à démarré
		Console.WriteLine("LongMethod1 autorise LongMethod3 à démarrer");
		longLoop();
		Console.WriteLine("LongMethod1 termine");
	}
 
	public void LongMethod2()
	{
		Console.WriteLine("LongMethod2 démarre");
		longLoop();
		_event2.Set(); // Thread sur LongMethod3 autorisé à démarré
		Console.WriteLine("LongMethod2 autorise LongMethod3 à démarrer");
		longLoop();
		Console.WriteLine("LongMethod2 termine");
	}
	public void LongMethod3()
	{
		Console.WriteLine("LongMethod3 démarre");
		longLoop();
		Console.WriteLine("LongMethod3 termine");
	}
 
}
class Program
{
	private static void scheduler()
	{
		ManualResetEvent event1 = new ManualResetEvent(false);
		ManualResetEvent event2 = new ManualResetEvent(false);
 
		ThreadTest threadTest = new ThreadTest(event1, event2);
		Thread thread1 = new Thread(new ThreadStart(threadTest.LongMethod1));
		Thread thread2 = new Thread(new ThreadStart(threadTest.LongMethod2));
		thread1.Start();
		thread2.Start();
		ManualResetEvent.WaitAll(new ManualResetEvent[] { event1, event2 });
		Thread thread3 = new Thread(new ThreadStart(threadTest.LongMethod3));
		thread3.Start();
 
	}
	static void Main(string[] args)
	{
		Thread thread_scheduler = new Thread(new ThreadStart(scheduler));
		thread_scheduler.Start();
		while (true)
		{
			Console.WriteLine("Entrer une caractére, F pour finir");
			ConsoleKeyInfo keyInfo = Console.ReadKey();
			if (keyInfo.KeyChar == 'F')
			{
				Environment.Exit(0);
			}
			else
			{
				Console.WriteLine(keyInfo.KeyChar);
			}
		}
	}
}

**Zarrows** · 09/02/2012, 12h03

Pourquoi tu as mit les 3 Thread dans une autre classe ?

**Bluedeep** · 09/02/2012, 12h07

Envoyé par Zarrows

Pourquoi tu as mit les 3 Thread dans une autre classe ?

Il s'agit d'un EXEMPLE.

Donc on essaye de faire DIDACTIQUE et LISIBLE.

Et que ça correspond à ce qui se fera en pratique (ma classe "métier" n'a pas à contenir son propre code de scheduling).

**Bluedeep** · 09/02/2012, 12h09

Une dernière version plus compacte avec les threads se lançant tous sur la même méthode et passage de paramètres.
Maintenant tu as tous les éléments pour continuer.

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
 
struct MyThreadsParam
{
	public ManualResetEvent SyncEvent;
	public int ThreadNumber;
}
public class ThreadTest
{
	private static void longLoop()
	{
		for (int i = 0; i < 1000; i++)
		{
			Thread.Sleep(10);
		}
	}
	public void LongMethod(object myParam)
	{
		MyThreadsParam param = (MyThreadsParam)myParam;
		Console.WriteLine("LongMethod{0} démarre", param.ThreadNumber);
		longLoop();
		if (param.SyncEvent != null)
		{
			param.SyncEvent.Set(); // Thread sur LongMethod3 autorisé à démarré
			Console.WriteLine("LongMethod{0} autorise LongMethod3 à démarrer", param.ThreadNumber);
		}
		longLoop();
		Console.WriteLine("LongMethod{0} termine", param.ThreadNumber);
	}
}
class Program
{
	static ThreadTest threadTest = new ThreadTest();
 
	private static MyThreadsParam scheduleOneThread(int number, bool hasSyncEvent)
	{
		ManualResetEvent sync_event = null;
		if (hasSyncEvent)
		{
			sync_event = new ManualResetEvent(false);
		}
		MyThreadsParam threadParam = new MyThreadsParam() { SyncEvent = sync_event, ThreadNumber = number };
		Thread thread = new Thread(new ParameterizedThreadStart(threadTest.LongMethod));
		thread.Start(threadParam);
		return threadParam;
 
	}
	private static void scheduler()
	{
		MyThreadsParam threadParam1 = scheduleOneThread(1, true); // on démarre 1
		MyThreadsParam threadParam2 = scheduleOneThread(2, true); // on démarre 2
		ManualResetEvent.WaitAll(new ManualResetEvent[] { threadParam1.SyncEvent, threadParam2.SyncEvent });
		MyThreadsParam threadParam3 = scheduleOneThread(3, false); // on démarre 3, quand 1 et 2 ont signalé
	}
	static void Main(string[] args)
	{
		Thread thread_scheduler = new Thread(new ThreadStart(scheduler));
		thread_scheduler.Start();
		while (true)
		{
			Console.WriteLine();
			Console.WriteLine("Entrer une caractére, F pour finir : ");
			ConsoleKeyInfo keyInfo = Console.ReadKey();
			if (keyInfo.KeyChar == 'F')
			{
				Environment.Exit(0);
			}
		}
	}
}

**Zarrows** · 10/02/2012, 14h43

Après de longues heure de travail voici ce que j'ai fait :

J'ai creer une thread qui est lancer à partir de mon main, Cet thread est interrompu après le lancement des deux premières pour attendre de lancer la troisième.

Merci BlueDeep de m'avoir aidé. Je n'est pas bien compris l'histoire de ManualResetEvent et la solution que j'ai trouvé me parait plus simple pour un débutant comme moi. Merci encore !

Lancer une Thread après la fin de deux autres [Débutant]

C#

Discussions similaires

Partager

Partager