[c#]Synchronisation entre évenements

Version imprimable

Salut,

j'ai un thread qui fait la tache suivante (pour simplifier):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 private void work() { while (true) { if (NewMessage) OnMessageReceived(); } } protected virtual void OnMessageReceived() { EventHandler handler = get_next_handler(); handler(this, EventArgs.Empty); }
la methode get_next_handler me renvoie un delegate sur successivement les methodes suivantes:
Code:

1 2 3 4 5 6 7 8 9 public void Handler1(object sender, EventArgs e) { Thread.Sleep(1000); } public void Handler2(object sender, EventArgs e) { Thread.Sleep(2000); }
mais voila, les deux handlers prennent du temps à s'exécuter, et bloquent la méthode OnMessageReceived... comment rendre cette méthode non-bloquante avec les contraintes suivantes:
Handler2 ne doit jamais s'exécuter pendant que Handler1 s'éxecute, et la solution ne doit pas modifier l'implémentation de Handler1 ni Handler2...
c'est possible de faire ça? je ne vois pas
merci d'avance

06/12/2006, 22h27
Jérôme Lambert
Quand tu fais ceci :
Code:

1 2 3 4 5 6 7 8 private void work() { while (true) { if (NewMessage) OnMessageReceived(); } }
Ne serait pas bien de faire un Thread.Sleep(100); juste après le if histoire que le cpu ne soit pas monopolisé dans un handler qui boucle et bloque à l'infini ?

Par contre, je ne suis pas sûr si celà va résoudre ton problème.

Dans le vrai code ça ne bloque pas le CPU :)
c'etait juste pour aller plus vite en rédigeant l'exemple.
Sinon je pense avoir trouver une solution:

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
        private struct TaskInfo
        {
            public EventHandler Handler;
            public object Sender;
            public EventArgs Args;
        }
 
        private Queue<TaskInfo> _pending = new Queue<TaskInfo>;
 
        private void work()
        {
            new Thread(new ThreadStart(dispatcher)).Start();
            while (true)
                if (NewMessage)
                    OnMessageReceived();
        }
 
        protected virtual void OnMessageReceived()
        {
            TaskInfo info;
            info.Handler = get_next_handler();
            info.Sender = this;
            info.Args = EventArgs.Empty;
            lock (_pending)
            {
                _pending.Enqueue(info);
                Monitor.Pulse(_pending);
            }
        }
 
        private void dispatcher()
        {
            while (true)
            {
                TaskInfo info;
                lock (_pending)
                {
                    while (_pending.Count == 0)
                        Monitor.Wait(_pending);
                    info = _pending.Dequeue();
                }
                info.Handler(info.Sender, info.Args);
            }
        }

07/12/2006, 22h01
Pilloutou

Bonsoir,

Ou plus simplement, tu peux utiliser la méthode asynchrone d'un delegate BeginInvoke et EndInvoke. A mon avis, c'est plus adapté à ton cas.

Bye
07/12/2006, 23h34
b4u

mais dans ce cas il y a des chances que Handler2 se lance avant que Handler1 soit terminé non? ou alors je ne vois pas bien ce que tu proposes.
08/12/2006, 08h26
Pilloutou

Bonjour,

oui effectivement, je crois que j'ai répondu un peu vite, désolé.

Citation:

Handler2 ne doit jamais s'exécuter pendant que Handler1 s'éxecute

J'avais dû sauter cette ligne.

Désolé.

Sinon ça n'a pas l'air mal ce que tu as fait.
Ca fonctionne bien ?

Bye
08/12/2006, 09h03
b4u

Salut,

aucun probleme! ta suggestion m'a fait me demander pourquoi c'etait important que les handlers se lancent l'un apres l'autre apres tout... en fait, Handler1 et Handler2 sont des méthodes écrites par l'utilisateur de la classe que je développe. Je ne veux pas l'obliger à devoir écrire du code synchronisé, donc j'essaye au maximum de procurer une implémentation thread-safe :)