Come evitare il blocco (C ++, Win32)

Question

Sto creando una DLL che deve rispondere alle richieste di un'applicazione. Uno dei requisiti dell'applicazione è che il completamento di una chiamata non dovrebbe richiedere molto tempo.

Dire, ho una funzione foo (), che viene chiamata dall'applicazione host:

int foo(arg){
    // some code i need to execute, say,
    LengthyRoutine();
    return 0;
}

Diciamo che foo deve eseguire un'attività (o chiamare una funzione) che sicuramente impiegherà molto tempo. L'applicazione mi consente di impostare una variabile di attesa; se questa variabile è diversa da zero quando viene restituito foo, chiama foo ancora e ancora (reimpostando la variabile wait prima di ogni chiamata) fino a quando l'attesa non viene restituita 0.

Qual è l'approccio migliore a questo?

Devo andare:

int foo(arg){

    if (inRoutine == TRUE) {
        wait = 1;
        return 0;
    } else {
        if (doRoutine == TRUE) {
             LengthyRoutine();
             return 0;
        }
    }

    return 0;
}

Questo non risolve davvero il problema che il completamento di LengthyRoutine richiederà molto tempo. Devo generare un thread di qualche tipo che si aggiorna inRoutine a seconda che abbia completato o meno il suo compito?

Grazie ..

Answer 1

Generare un altro thread è praticamente il modo migliore per farlo, assicurati solo di impostare le variabili dei risultati prima di impostare la variabile che dice che hai finito per evitare le condizioni di gara. Se questo viene chiamato spesso, potresti voler generare in anticipo un thread di lavoro e riutilizzarlo per evitare il sovraccarico dell'inizio del thread.

Esiste un'altra possibile soluzione, esegui parte del lavoro ogni volta che viene chiamata la funzione, tuttavia ciò trascorre più tempo nella DLL e probabilmente non è ottimale, oltre ad essere più complesso per implementare il codice di lavoro per la maggior parte degli algos .

Answer 2

Se si sta programmando in C, utilizzare il callback - passare il callback a pippo. Devi concordare la firma di richiamata e fare un po 'di pulizie per attivarlo quando il lavoro in LengthyRoutine è terminato.

typedef (void) callbackFunction(void);

int foo(arg, callbackFunction)
{
   // some code i need to execute, say,
   // register callback and return right away
   // Trigger the LengthyRoutine to run after this function returns

   return 0;
}

LengthyRoutine()
{
   // do lenghty routine

   // now inform the caller with their suppiled callback
   callbackFunction();
}

Essenzialmente Observer Lo schema in C. C ++ rende il lavoro un molto più facile / più pulito secondo me

Answer 3

Se una situazione rara incredibile in cui LengthyRoutine () non è un codice di terze parti e hai tutta la fonte ed è possibile dividerlo, puoi prendere in considerazione l'uso di coroutine .