Può questa discussione diventare uno zombi

Question

Ho un programma che avvia un thread (utilizzando pthreads) che eseguirà qualche attività in background per il resto del programma. Il programma principale viene eseguito in un terminale e un caso d'uso comune è quello di chiuderlo prima che esca da solo usando Ctrl-C. Qualcuno mi ha chiesto di variare i fili che ho generato per diventare zombie. Non avevo ancora pensato a questo problema e sono un principiante nella programmazione multi-thread in generale. Ho creato quello che spero sia un programma di test piccolo, ma completo e autonomo che dovrebbe imitare il comportamento del programma reale.

Nel codice seguente, esiste il rischio che il thread generato diventi uno zombie? Ricorda che il programma potrebbe essere ucciso usando Ctrl-C, forse questo è uno scenario speciale, non ne sono sicuro.

In questo momento, il thread continua a essere eseguito dopo che l'oggetto MyThread è stato eliminato. Questo non è davvero un problema, perché nel vero programma, l'oggetto MyThread viene distrutto proprio mentre il programma sta per uscire comunque. Voglio solo sapere che il thread non rischia mai di diventare uno zombi nel sistema dopo che il genitore se n'è andato.

Suppongo che potrei avere una variabile protetta da mutex che controllo nel thread func ogni iterazione per dirmi se dovrei uscire, e potrei impostare questa variabile su true nel distruttore MyThread, ma forse non lo faccio bisogno di farlo? Scusa, ho un po 'di tempo, grazie per aver letto e grazie in anticipo per qualsiasi aiuto!

#include <iostream> 
#include <pthread.h> 
#include <unistd.h> 

class MyThread 
{ 
public: 
    MyThread() : is_running(false) {} 

    void Run() 
    { 
     if (!is_running) { 
     if (pthread_create(&thread, NULL, 
          (void * (*)(void *))RunThread, 
          NULL) == 0) { 
      is_running = true; 
     } 
     else { 
      std::cerr << "pthread_create() failed." << std::endl; 
     } 
     } 
     else { 
     std::cout << "The thread was already running." << std::endl; 
     } 
    } 
private: 
    static void * RunThread(void */*arg*/) 
    { 
     while (true) { 
     sleep(1); 
     std::cout << "Hello from RunThread" << std::endl; 
     } 
     return NULL; 
    } 

    pthread_t thread; 
    bool is_running; 
}; 

int main() 
{ 
    MyThread *thread = new MyThread; 

    thread->Run(); 

    std::cout << "Going to sleep for five seconds." << std::endl; 
    sleep(5); 
    std::cout << "No longer asleep, deleting thread object." << std::endl; 

    delete thread; 

    std::cout << "Hit enter to exit program." << std::endl; 
    std::cin.get(); 

    return 0; 
} 

Answer 1

I fili non diventano zombi; i processi Quando uccidi un processo, questo uccide automaticamente tutti i suoi thread.

In poche parole, non è necessario fare nulla di speciale solo perché è in esecuzione un secondo thread.

Answer 2

Ctrl+C -ing out di un programma per impostazione predefinita uccide l'intera struttura del processo, inclusi eventuali processi e thread secondari. Quindi non preoccuparti se non configuri un gestore di segnale personalizzato per SIGINT.