Linux, C: beende mehrere Threads nach einigen Sekunden (Timer?)

Question

Linux, C. Ich habe mehrere Threads erstellt, um Workloads auszuführen, und ich möchte diesen Threads signalisieren, dass sie nach einer bestimmten Sekunde/Zeit anhalten/beenden. Wie implementiere ich das mit C?

void *do_function(void *ptr) 
{ 
    //calculating, dothe workload here; 
} 

int run(struct calculate_node *node) 
{ 
    pthread_t threads[MAX_NUM_THREADS]; 
    for (t = 0; t < node->max_threads; t++) { 
     rc = pthread_create(&threads[t], NULL, do_function, (void*)node); 
     if(rc) return -1; 
    } 

    //how do I create timer here to fire to signal those threads to exit after specified seconds? 


    for (t = 0; t < node->max_threads; t++) { 
     pthread_join(threads[t], NULL); 
    } 
    free(threads); 
} 

danke!

Answer 1

Nicht sicher, ob es eine tragbare Möglichkeit gibt, ein Timer-Ereignis zu erstellen, aber wenn main nichts anderes zu tun hat, könnte es einfach sleep anrufen, um Zeit zu verschwenden.

Für die Signalisierung der Threads haben Sie zwei Möglichkeiten: kooperative Beendigung oder nicht kooperative Beendigung. Bei einer kooperativen Beendigung muss der Thread regelmäßig ein Flag überprüfen, um zu sehen, ob es beendet werden soll. Bei nichtkooperativer Beendigung rufen Sie pthread_cancel auf, um den Thread zu beenden. (Weitere Informationen über zusätzliche Funktionen, die zum ordnungsgemäßen Beenden des Threads verwendet werden können, finden Sie auf der Manpage für pthread_cancel.)

Ich finde, dass eine kooperative Beendigung einfacher zu implementieren ist. Hier ein Beispiel:

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

static int QuitFlag = 0; 
static pthread_mutex_t QuitMutex = PTHREAD_MUTEX_INITIALIZER; 

void setQuitFlag(void) 
{ 
    pthread_mutex_lock(&QuitMutex); 
    QuitFlag = 1; 
    pthread_mutex_unlock(&QuitMutex); 
} 

int shouldQuit(void) 
{ 
    int temp; 

    pthread_mutex_lock(&QuitMutex); 
    temp = QuitFlag; 
    pthread_mutex_unlock(&QuitMutex); 

    return temp; 
} 

void *somefunc(void *arg) 
{ 
    while (!shouldQuit()) 
    { 
     fprintf(stderr, "still running...\n"); 
     sleep(2); 
    } 

    fprintf(stderr, "quitting now...\n"); 
    return(NULL); 
} 

int main(void) 
{ 
    pthread_t threadID; 

    if (pthread_create(&threadID, NULL, somefunc, NULL) != 0) 
    { 
     perror("create"); 
     return 1; 
    } 

    sleep(5); 
    setQuitFlag(); 
    pthread_join(threadID, NULL); 
    fprintf(stderr, "end of main\n"); 
} 

Answer 2

Zuerst müssen Sie die Zeit erstellen und starten. Im folgenden Beispiel ruft der Timer eine "Stop" -Funktion auf, die für das Unterbrechen der Threads verantwortlich ist. In gewisser Weise ist es eine der einfachsten Möglichkeiten.

void *notify_stop(void *); // Prototype 

int run(struct calculate_node *node) 
{ 
    ... 

    struct sigevent sev; 
    timer_t timer; 
    struct itimerspec tspec = { 0 }; 
    sev.sigev_notify = SIGEV_THREAD; // type of timer event 
    sev.sigev_notify_function = notify_stop; // call function 
    timer_create(CLOCK_MONOTONIC, &sevent, &timer); 
    tspec.it_interval.tv_sec = 5; // set time interval 
    tspec.it_interval.tv_nsec = 0; 
    tspec.it_value.tv_sec = 0; 
    tspec.it_value.tv_nsec = 0; 
    timer_set(timer, &tspec, NULL); // start timer 

    .... 
} 

Jetzt müssen Sie entscheiden, wie Sie Ihre Threads stoppen möchten. Eine Möglichkeit besteht darin, eine gemeinsam genutzte Variable zu verwenden, um die Ausgangsbedingung anzuzeigen:

volatile bool do_stop = false; 
void *do_function(void *ptr) 
{ 
    while (!do_stop) 
    { 
    //calculating, dothe workload here; 
    } 
} 
void *notify_stop(void *) 
{ 
    do_stop = true; // just set the variable to let other threads 
        // read it and stop 
}