Question équivalente à l'événement pthread windows

Question

J'ai le code suivant qui réplique les événements manuels Windows et les réinitialisations automatiques.

class event 
{ 
public: 
    event(bool signalled = false, bool ar = true) : 
     _auto(ar), 
     _signalled(signalled) 
    { 
     pthread_mutex_init(&_mutex, NULL); 
     pthread_cond_init(&_cond, NULL); 
    } 

    ~event() 
    { 
     pthread_cond_destroy(&_cond); 
     pthread_mutex_destroy(&_mutex); 
    } 

    void set() 
    { 
     pthread_mutex_lock(&_mutex); 

     // only set and signal if we are unset 
     if (_signalled == false) 
     { 
      _signalled = true; 

      pthread_cond_signal(&_cond); 
     } 

     pthread_mutex_unlock(&_mutex); 
    } 

    void wait() 
    { 
     pthread_mutex_lock(&_mutex); 

     while (_signalled == false) 
     { 
      pthread_cond_wait(&_cond, &_mutex); 
     } 

     // if we're an autoreset event, auto reset 
     if (_auto) 
     { 
      _signalled = false; 
     } 

     pthread_mutex_unlock(&_mutex); 
    } 

    void reset() 
    { 
     pthread_mutex_lock(&_mutex); 

     _signalled = false; 

     pthread_mutex_unlock(&_mutex); 
    } 

private: 
    pthread_mutex_t _mutex; 
    pthread_cond_t _cond; 
    bool _signalled; 
    bool _auto; 
}; 

Ma question entoure la « optimisation » Je l'ai mis en place dans la méthode set() où je ne convoquent que pthread_cond_signal() si l'événement a été non signalés. Est-ce une optimisation valide ou ai-je introduit un défaut subtil en le faisant.

Answer 1

Il y a certainement une différence de comportement due à cette "optimisation" si plusieurs threads attendent le même événement. Considérez cette séquence d'événements (mode de réarmement manuel):

thread 1 - wait 
thread 2 - wait 
thread 3 - wait 
thread 4 - set 
thread 4 - set 
thread 4 - set 
thread 4 - reset 

Avec votre code, pthread_cond_signal ne sera appelée une fois (un des fils débouchage 1-3); sans l'optimisation, il serait appelé 3 fois (débloquer tous les 3).

Je ne sais pas si c'est un "défaut" ou non, car je ne connais pas la sémantique précise de l'API Windows que vous émulez.

Answer 2

Je qualifierais _signalled avec volatile, pour éviter toute astuces astucieuses de compilateur concernant cette variable.

Answer 3

Pour les événements non réinitialisés automatiquement, vous ne réactivez qu'un seul thread sur un appel à set, mais vous arrêtez le blocage des threads supplémentaires. Cela ne me semble pas sain et crée une condition de race entre les serveurs et les wakers.