Wie man vermeidet, auf pthread_cond_t zu warten, wo das Signal bereits gesendet wurde

Question

Ich habe eine Logik in einer dynamischen Bibliothek, die einen Dienst ausführt, der von der Hauptprogrammdatei angefordert wird.

Wenn Sie aus dem Bibliothekscode start_service anrufen, müssen einige Vorbereitungen getroffen werden, bevor der Dienst betriebsbereit ist. Während dieser Zeit sollte der Hauptcode nicht versuchen, auf den Dienst zuzugreifen.

Um den Hauptcode zu benachrichtigen, wenn der Dienst bereit ist, verwende ich bedingte Variable und signalisiere die Hauptdatei.

Ich möchte einige Ratschläge über die beste Möglichkeit, eine Situation zu behandeln, wenn die Bibliothek vor dem Haupt-Code warten auf die bedingte Variable zu behandeln. in diesem Fall kann die Warte ewig dauern ...

hier ist der Service-Code:

extern pthread_cond_t cnd; 
extern pthread_mutex_t mtx; 

void start_service() 
{ 
    // getting serviceable.  
    pthread_cond_signal(&cnd); 
    main_loop(); 
} 

Und hier ist der Hauptcode.

pthread_cond_t cnd; 
pthread_mutex_t mtx; 

int main() 
{  
    pthread_cond_init(&cnd,NULL); 
    pthread_mutex_init(&mtx, NULL); 

    std::thread mytrd(&start_service); 
    ... 
    pthread_mutex_lock(&mtx); 

    pthread_cond_wait(&cnd, &mtx); // what happens if we get here after the signal already sent. 
    pthread_mutex_unlock(&mtx); 
    ... 
} 

P.S das gewünschte Verhalten sollte sein, dass die Haupt-Code zu vermeiden für die bedingte Variable warten, wenn es bereits signalisiert hat.

Answer 1

Sie benötigen ein Prädikat und umschließen den wait in einer Prüfung für das Prädikat:

pthread_mutex_lock(&mtx); 
    while(! predicate) pthread_cond_wait(&cnd, &mtx); 
    pthread_mutex_unlock(&mtx); 

Auf diese Weise startet der Thread tut Ereignis zu warten, wenn es brauchen tut. Der zweite Grund, den Sie brauchen, ist die Vermeidung von ungewollten Wakeups, dh pthread_cond_wait kann zurückkommen, auch wenn der andere Thread den Zustand nicht signalisiert hat.

Der andere Thread hat dann zu tun (Sie müssen den Mutex sperren, das Prädikat zu schützen):

pthread_lock_mutex(&mtx); 
predicate = true; 
pthread_cond_signal(&cnd); 
pthread_unlock_mutex(&mtx); 

Answer 2

Sie eine Semaphore mit anfänglicher Anzahl von 0 verwenden können, so main blockiert wird, bis start_service() Anstieg Semaphore zählen zu 1. Wenn vor dem Block Anruf in main, start_service() erhöht die Semaphor-Zählung zu 1, Haupt wird nie in Wartezustand eintreten.Etwas wie unten.

void start_service() 
{ 
    // getting serviceable.  
    sem_post(&sem_mutex);//increases to 1 
    main_loop(); 
} 
int main() 
{ 
    sem_init(&sem_mutex, 0, 0);//initially blocked. 
    std::thread mytrd(&start_service); 
    sem_wait(&sem_mutex); 
    ... 
}