Cross Thread et modification de variable

Version imprimable

Bonjour,

J'ai un programme qui comporte un thread principal, et un thread qui surveille la valeur d'une variable et execute la commande correspondante.
Mon probleme est que selon la durée de commande, mon thread peut rater des instructions le temps de traiter la précédente.

Un bout de code vaut mieux qu'un long discours :

Code:

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
namespace Test
{
    class Program
    {
 
 
        static void Main(string[] args)
        {
            DoWork test = new DoWork();
        }
 
    }
 
    class DoWork
    {
        private String ActionTodo = "nothing";
        Thread ActionThread;
        bool stopThread = false;
 
        //Constructeur
        public DoWork()
        {
            ActionThread = new Thread(ActionLoop);
            ActionThread.IsBackground = true;
            ActionThread.Start();
 
            //...ici un tas d'action
            //puis premiere demande d'action
            ActionTodo = "coucou"; 
            Thread.Sleep(60); //Tempo de 60 pour etre sur que mon nombre soit traité dans l'ActionLoop
 
            //...ici un tas d'action
 
            //puis deuxieme demande d'action
            ActionTodo = "bonjour";
            Thread.Sleep(60);
 
            //...ici un tas d'action
 
            //puis troisieme demande d'action
            ActionTodo = "youpie";
            Thread.Sleep(60); 
 
            //...ici un tas d'action
 
            //puis quatrieme demande d'action qui n'existe pas
            ActionTodo = "foo"; 
            Thread.Sleep(60);
 
            //puis cinquieme demande d'action 
            ActionTodo = "cava";
            Thread.Sleep(60);
 
            //...ici un tas d'action
 
            //puis derniere demande d'action
            ActionTodo = "byebye"; 
            Thread.Sleep(60);
 
            Console.ReadKey();
            stopThread = true;
        }
 
        public void ActionLoop()
        {
            while (!stopThread) //On tourne tant que l'on arrete pas le programme
            {
                Random rand = new Random();
                int tempo = 0;
                //On teste la valeur de ActionTodo
                switch (ActionTodo)
                {
                    case "coucou":
                        tempo = rand.Next(200); //temporisation arbitraire simulant un temps de traitement variable...
                        Console.WriteLine("Coucou (" + tempo +"ms)");
                        Thread.Sleep(tempo); 
                        break;
                    case "bonjour":
                        tempo = rand.Next(200);
                        Console.WriteLine("Bonjour(" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "youpie":
                        tempo = rand.Next(200);
                        Console.WriteLine("Youpie(" + tempo + "ms)");
                        Thread.Sleep(tempo); 
                        break;
                    case "cava":
                        tempo = rand.Next(200);
                        Console.WriteLine("Ca va ? (" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "byebye":
                        tempo = rand.Next(200);
                        Console.WriteLine("Au Revoir(" + tempo + "ms)");
                        Thread.Sleep(tempo); 
                        break;
                    case "nothing":
                    default: break;
                }
                //On remet ActionToDo à "nothing" pour éviter de tourner en boucle sur la meme action
                ActionTodo = "nothing";
                Thread.Sleep(50);
            }
        }
    }
}

Le temps d'afficher le message étant variable, je n'ai pas deux fois le meme résultat.
ex :

Citation:

Coucou (192ms)
Ca va ? (92ms)

Citation:

Coucou (54ms)
Youpie (153ms)

etc...

Ma question est donc la suivante :

Comment puis-je me débrouiller pour ne pas rater de commande ?

Ou comment puis-je demander à mon thread principal d'attendre que le thread ActionLoop ai fini sa commande avant d'en lancer une nouvelle ?

Pour l'exemple, on peut le faire en "synchronisant" le traitement avec un AutoResetEvent par exemple. Cela permet de bloquer le traitement tant que la donnée n'est pas prête et d'attendre que le traitement ai fini pour passer à la suite.

Code:

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            DoWork test = new DoWork();
        }
    }
 
    class DoWork
    {
        private String ActionTodo = "nothing";
        bool stopThread = false;
        private AutoResetEvent resetEvent1 = new AutoResetEvent(false);
        private AutoResetEvent resetEvent2 = new AutoResetEvent(false);
 
        //Constructeur
        public DoWork()
        {
            Thread ActionThread = new Thread(ActionLoop);
            ActionThread.IsBackground = true;
            ActionThread.Start();
 
            //...ici un tas d'action
            //puis premiere demande d'action
            ActionTodo = "coucou";
            // On signale que la donnée est prête.
            resetEvent1.Set();
            // On attend que le thread ai traité la donnée.
            resetEvent2.WaitOne();
 
            //...ici un tas d'action
 
            //puis deuxieme demande d'action
            ActionTodo = "bonjour";
            resetEvent1.Set();
            resetEvent2.WaitOne();
 
            //...ici un tas d'action
 
            //puis troisieme demande d'action
            ActionTodo = "youpie";
            resetEvent1.Set();
            resetEvent2.WaitOne();
 
            //...ici un tas d'action
 
            //puis quatrieme demande d'action qui n'existe pas
            ActionTodo = "foo";
            resetEvent1.Set();
            resetEvent2.WaitOne();
 
            //puis cinquieme demande d'action 
            ActionTodo = "cava";
            resetEvent1.Set();
            resetEvent2.WaitOne();
 
            //...ici un tas d'action            
 
            //puis derniere demande d'action
            ActionTodo = "byebye";
            resetEvent1.Set();
            resetEvent2.WaitOne();
 
            Console.ReadKey();
            stopThread = true;
        }
 
        public void ActionLoop()
        {
            int tempo;
            Random rand = new Random();
 
            while (!stopThread) //On tourne tant que l'on arrete pas le programme
            {
                // On attend que la donnée soit prête.
                resetEvent1.WaitOne();
 
                //On teste la valeur de ActionTodo
                switch (ActionTodo)
                {
                    case "coucou":
                        tempo = rand.Next(200); //temporisation arbitraire simulant un temps de traitement variable...
                        Console.WriteLine("Coucou (" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "bonjour":
                        tempo = rand.Next(200);
                        Console.WriteLine("Bonjour(" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "youpie":
                        tempo = rand.Next(200);
                        Console.WriteLine("Youpie(" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "cava":
                        tempo = rand.Next(200);
                        Console.WriteLine("Ca va ? (" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "byebye":
                        tempo = rand.Next(200);
                        Console.WriteLine("Au Revoir(" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "nothing":
                    default:
                        break;
                }
 
                //On remet ActionToDo à "nothing" pour éviter de tourner en boucle sur la meme action
                ActionTodo = "nothing";
 
                // On signale que la donnée est traitée.
                resetEvent2.Set();
            }
        }
    }
}

Par contre le thread ne sert à rien à ce moment, puisqu'on doit le bloquer pour pouvoir bien enchaîner les instructions. Autant appeler une méthode avec l'action à traiter.

Une solution éventuelle serait d'utiliser une file. Tu ajoutes les actions dans une file et le thread traite chaque action en attente.

Code:

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            DoWork test = new DoWork();
        }
    }
 
    class DoWork
    {
        bool stopThread = false;
        private Queue<string> actions;
 
        //Constructeur
        public DoWork()
        {
            actions = new Queue<string>();
 
            Thread ActionThread = new Thread(ActionLoop);
            ActionThread.IsBackground = true;
            ActionThread.Start();
 
            //...ici un tas d'action
            //puis premiere demande d'action
            actions.Enqueue("coucou");
 
            //puis deuxieme demande d'action
            actions.Enqueue("bonjour");
 
            //puis troisieme demande d'action
            actions.Enqueue("youpie");
 
            //puis quatrieme demande d'action qui n'existe pas
            actions.Enqueue("foo");
 
            //puis cinquieme demande d'action 
            actions.Enqueue("cava");
 
            //puis derniere demande d'action
            actions.Enqueue("byebye");
 
            Console.ReadKey();
            stopThread = true;
        }
 
        public void ActionLoop()
        {
            int tempo;
            Random rand = new Random();
 
            while (!stopThread) //On tourne tant que l'on arrete pas le programme
            {
                string action = "nothing";
                if (actions.Count != 0)
                {
                    action = actions.Dequeue();
                }
 
                switch (action)
                {
                    case "coucou":
                        tempo = rand.Next(200); //temporisation arbitraire simulant un temps de traitement variable...
                        Console.WriteLine("Coucou (" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "bonjour":
                        tempo = rand.Next(200);
                        Console.WriteLine("Bonjour(" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "youpie":
                        tempo = rand.Next(200);
                        Console.WriteLine("Youpie(" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "cava":
                        tempo = rand.Next(200);
                        Console.WriteLine("Ca va ? (" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "byebye":
                        tempo = rand.Next(200);
                        Console.WriteLine("Au Revoir(" + tempo + "ms)");
                        Thread.Sleep(tempo);
                        break;
                    case "nothing":
                    default:
                        Thread.Sleep(100);
                        break;
                }
            }
        }
    }
}

30/09/2009, 13h49
alexadvance

Merci, c'est exactement les deux méthodes que je voulais tester sans savoir les faire...

Je teste ca tout de suite !