Comportamento EventWaitHandle per pthread_cond_t

Question

Di recente ho visto la luce del potente comportamento di EventWaitHandle in C # e ho deciso di spostare alcune funzionalità in un'applicazione sorella per fare lo stesso. L'unico problema è che l'app sorella è scritta in C.

Non è un grosso problema, sto usando pthreads, che ha un tipo di dati pthread_cond_t che consente la segnalazione. La mia unica domanda è: è possibile che un cond venga "segnalato" prima che qualcosa ci stia aspettando?

In questo momento il mio test dice di no. Cioè, se ThreadA emette un segnale prima che ThreadB sia in attesa, ThreadB attenderà indefinitamente. Esiste un altro tipo di pthread che posso usare che si avvicina alla funzionalità di EventWaitHandle in C #? Viene segnalato un oggetto, il che significa che il primo thread in attesa su di esso, passerà immediatamente e lo imposterà su senza segno.

Avvolgere pthread_cond in un'altra struttura di dati non sarebbe troppo difficile per raggiungere questo obiettivo. Ma ancora una volta, questa funzionalità è già disponibile nella libreria pthread?

Answer 1

Se stai usando correttamente le variabili di condizione, questo non ha importanza.

Il flusso di base del codice dovrebbe essere (in pseudocodice):

lock(lockobj);
while (!signalled) {
    wait(condvar);
}
signalled = false;
unlock(lockobj);

sul lato di attesa e:

lock(lockobj);
signalled = true;
notify(condvar);
unlock(lockobj);

sul lato segnalamento. (Naturalmente, l'oggetto di blocco e la variabile di condizione utilizzati devono essere gli stessi su entrambi i lati.) Spero che questo aiuti!

Answer 2

Risposta alternativa (anche in pseudocodice) se si desidera segnalazioni multiple (vale a dire, se segnalato due volte, due thread possono attendere prima che lo stato venga nuovamente annullato).

Lato in attesa:

lock(lockobj);
while (signalled != 0) {
    wait(condvar);
}
--signalled;
unlock(lockobj);

Lato segnalazione:

lock(lockobj);
++signalled;
notify(condvar);
unlock(lockobj);

Answer 3

Ho finito per racchiudere un tipo di condizione in una nuova struttura e ho creato alcune semplici funzioni per comportarsi in modo simile a EventWaitHandle da C #. Avevo bisogno di due mutex per ottenere il giusto accesso serializzato.

Il cond_mutex viene utilizzato per l'attesa sulla variabile condizionale, mentre data_mutex viene utilizzato quando si imposta lo stato da segnalato a non segnalato.

La modalità di ripristino è la stessa di C #. AUTO o MANUALE. Ciò consente a event_wait_t di ripristinarsi automaticamente dopo l'attesa. O lasciare che il programmatore lo faccia manualmente con una chiamata a event_wait_reset (event_wait_t * ewh);