Discussion :

[b4u]

Salut,

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

Code c# :

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 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 c# :

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

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

[Jérôme Lambert]

Quand tu fais ceci :

Code :

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

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.

[b4u]

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 c# :

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
        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);
            }
        }

[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

[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.

[Pilloutou]

Bonjour,

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

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

[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