IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

[c#]Synchronisation entre évenements


Sujet :

C#

  1. #1
    b4u
    b4u est déconnecté
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 87
    Par défaut [c#]Synchronisation entre évenements
    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

  2. #2
    Rédacteur

    Avatar de Jérôme Lambert
    Homme Profil pro
    Développeur .NET
    Inscrit en
    Novembre 2003
    Messages
    4 451
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Belgique

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Novembre 2003
    Messages : 4 451
    Par défaut
    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.

  3. #3
    b4u
    b4u est déconnecté
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 87
    Par défaut
    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);
                }
            }

  4. #4
    Membre éclairé
    Inscrit en
    Août 2006
    Messages
    381
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 381
    Par défaut
    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

  5. #5
    b4u
    b4u est déconnecté
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 87
    Par défaut
    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.

  6. #6
    Membre éclairé
    Inscrit en
    Août 2006
    Messages
    381
    Détails du profil
    Informations forums :
    Inscription : Août 2006
    Messages : 381
    Par défaut
    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

  7. #7
    b4u
    b4u est déconnecté
    Membre confirmé
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    87
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 87
    Par défaut
    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

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Synchronisation entre client et server // gestion du lag
    Par phraides dans le forum Développement 2D, 3D et Jeux
    Réponses: 3
    Dernier message: 26/07/2006, 19h01
  2. synchronisation entre BD Oracle : Redo logs
    Par karimarien dans le forum Oracle
    Réponses: 7
    Dernier message: 17/07/2006, 18h49
  3. Réponses: 9
    Dernier message: 21/12/2005, 19h05
  4. Synchronisation entre 2 bases ACCESS
    Par Tchupacabra dans le forum Access
    Réponses: 2
    Dernier message: 18/10/2005, 15h24
  5. Synchronisation entre 2 threads
    Par bodbod dans le forum C++
    Réponses: 8
    Dernier message: 20/08/2004, 18h29

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo