Comprobación del estado de un proceso secundario en C++

Question

Tengo un programa que usa fork() para crear un proceso secundario. He visto varios ejemplos que usan wait() para esperar a que el proceso hijo finalice antes del cierre, pero me pregunto qué puedo hacer para simplemente verificar si el proceso del archivo aún se está ejecutando.

, básicamente, tienen un bucle infinito y quiero hacer algo como:

if(child process has ended) break;

¿Cómo podría ir haciendo esto?

Answer 1

Utilice waitpid() con la opción WNOHANG.

int status; 
pid_t result = waitpid(ChildPID, &status, WNOHANG); 
if (result == 0) { 
    // Child still alive 
} else if (result == -1) { 
    // Error 
} else { 
    // Child exited 
} 

Answer 2

No es necesario esperar a que un niño hasta que llegue la señal SIGCHLD. Si ha recibido esa señal, puede llamar al wait y ver si es el proceso secundario que está buscando. Si no ha recibido la señal, el niño todavía está corriendo.

Obviamente, si no tiene que hacer nada individualmente, el niño termina, simplemente llame al wait.

Answer 3

EDIT: Si solo quieres saber si el proceso hijo dejó de ejecutarse, entonces las otras respuestas son probablemente mejores. El mío tiene más que ver con la sincronización cuando un proceso puede hacer varios cálculos, sin necesariamente terminar.

Si tiene algún objeto que represente el cálculo secundario, agregue un método como bool isFinished() que devolverá verdadero si el elemento secundario ha finalizado. Tener un miembro bool privado en el objeto que representa si la operación ha finalizado. Finalmente, tenga otro método privado setFinished(bool) en el mismo objeto que su hijo procesa llamadas cuando termine su cálculo.

Ahora lo más importante es bloqueos mutex. Asegúrese de tener un mutex por objeto que bloquee cada vez que intente acceder a cualquier miembro, incluso dentro de los métodos bool isFinished() y setFinished(bool).

Edit2: (algunas aclaraciones OO)

Dado que se me pidió que explicar cómo esto podría hacerse con OO, voy a dar algunas sugerencias, aunque depende en gran medida el problema general, así que toma esto con un montón de sal. Tener la mayor parte del programa escrito en estilo C, con un objeto flotando alrededor es inconsistente.

Como un simple ejemplo, usted podría tener una clase llamada ChildComputation

class ChildComputation { 

    public: 
    //constructor 
    ChildComputation(/*some params to differentiate each child's computation*/) : 
     // populate internal members here { 
    } 
    ~ChildComputation(); 

    public: 
    bool isFinished() { 
     m_isFinished; // no need to lock mutex here, since we are not modifying data 
    } 

    void doComputation() { 
     // put code here for your child to execute 
     this->setFinished(true); 
    } 

    private: 
    void setFinished(bool finished) { 
     m_mutex.lock(); 
     m_isFinished = finished; 
     m_mutex.unlock(); 
    } 

    private: 
    // class members 
    mutex m_mutexLock; // replace mutex with whatever mutex you are working with 
    bool m_isFinished; 
    // other stuff needed for computation 
} 

En su programa principal, donde tenedor:

ChildComputation* myChild = new ChildComputation(/*params*/); 
ChildPID= fork(); 
if (ChildPID == 0) { 
    // will do the computation and automatically set its finish flag. 
    myChild->doComputation(); 
} 
else { 
    while (1) { // your infinite loop in the parent 
     // ... 

     // check if child completed its computation 
     if (myChild->isFinished()) { 
      break; 
     } 
    } 

    // at the end, make sure the child is no runnning, and dispose of the object 
    // when you don't need it. 
    wait(ChildPID); 
    delete myChild; 
} 

esperanza que tiene sentido.

Para reiterar, lo que he escrito anterior es un fea amalgama de C y C++ (no en términos de sintaxis, pero el estilo/diseño), y es justo allí para darle una idea de la sincronización con OO en tu contexto