Clase wxCondition

Las variables wxCondition corresponden a condiciones pthread o a objetos de eventos Win32.

Se pueden utilizar en una aplicación multihilo para esperar hasta que la condición dada se cumpla, lo que ocurre cuando la condición se señala.

Nota: Es preferible utilizar std::condition en lugar de esta clase en el nuevo código.

Por ejemplo, si un subproceso de trabajo está realizando una tarea larga y otro subproceso tiene que esperar hasta que termine, este último subproceso esperará en el objeto de condición y el subproceso de trabajo lo señalará al salir (este ejemplo no es perfecto porque, en este caso concreto, sería mucho mejor utilizar wxThread::Wait para el subproceso de trabajo, pero si hay varios subprocesos de trabajo, ya tiene mucho más sentido).

Hay que tener en cuenta que una llamada a wxCondition::Signal puede producirse antes de que el otro subproceso llame a wxCondition::Wait y, al igual que con las condiciones pthread, la señal se pierde, por lo que si se quiere asegurar no perderla, se debe mantener el mutex asociado a la condición inicialmente bloqueado y volver a bloquearlo antes de llamar a wxCondition::Signal. Por supuesto, esto significa que esta llamada se bloqueará hasta que otro subproceso llame a wxCondition::Wait.

Ejemplo

Este ejemplo muestra cómo un subproceso principal puede iniciar un subproceso secundario que comienza a ejecutarse y luego espera hasta que el subproceso principal le indique que continúe:

class MySignallingThread : public wxThread
{
public:
    MySignallingThread(wxMutex *mutex, wxCondition *condition)
    {
        m_mutex = mutex;
        m_condition = condition;
    }
 
    virtual ExitCode Entry()
    {
        ... hacer nuestro trabajo ...
 
        // Informar a los demás subprocesos que estamos a punto de terminar: 
        // ¡debemos bloquear primero el mutex o podríamos señalar la condición 
        // antes de que los subprocesos en espera comiencen a esperar en él!
        wxMutexLocker lock(*m_mutex);
        m_condition->Broadcast(); // igual que Signal() aquí: sólo un cliente en espera.
 
        return 0;
    }
 
private:
    wxCondition *m_condition;
    wxMutex *m_mutex;
};
 
int main()
{
    wxMutex mutex;
    wxCondition condition(mutex);
 
    // El mutex debe estar inicialmente bloqueado.
    mutex.Lock();
 
    // crea y ejecuta el subproceso, pero hay que tener en cuenta que no se podrá salir 
    // (ni señalar su salida) antes de que desbloqueemos el mutex a continuación.
    MySignallingThread *thread = new MySignallingThread(&mutex, &condition);
 
    thread->Run();
 
    // esperar a que finalice el subproceso: Wait() desbloquea de forma atómica
    // el mutex, lo que permite que el subproceso continúe y comienza a esperar.
    condition.Wait();
 
    // Ahora podemos salir.
    return 0;
}

Por supuesto, aquí sería mucho mejor utilizar simplemente un hilo unible y llamar a wxThread::Wait en él, pero este ejemplo ilustra la importancia de bloquear correctamente el mutex cuando se utiliza wxCondition.

Funciones miembro

wxCondition()

~wxCondition()

Broadcast()

IsOk()

Signal()

Wait()

Wait()

while ( !predicate() )
{
    wxCondError e = Wait();
    if ( e != wxCOND_NO_ERROR )
        return e;
}
return wxCOND_NO_ERROR;

condvar.Wait([]{return value == 1;});

WaitTimeout()