problème Pthreads et quelques questions

Question

#include<pthread.h> 
#include<stdio.h> 
#include<stdlib.h> 
#include<time.h> 
#define NUM_THREADS 8 

char *messages[NUM_THREADS]; 

struct thread_data 
{ 
    int thread_id; 
    int sum; 
    char *message; 
}; 

struct thread_data thread_data_array[NUM_THREADS]; 

void *PrintHello(void *threadarg) 
{ 
    int taskid, sum; 
    char *hello_msg; 
    struct thread_data *my_data; 

    sleep(1); 
    my_data = (struct thread_data *) threadarg; 
    taskid = my_data->thread_id; 
    sum = my_data->sum; 
    hello_msg = my_data->message; 
    printf("Thread %d: %s Sum=%d\n", taskid, hello_msg, sum); 
    pthread_exit(NULL); 
} 

int main(int argc, char *argv[]) 
{ 
pthread_t threads[NUM_THREADS]; 
//int *taskids[NUM_THREADS]; 
int rc, t, sum; 

sum=0; 
messages[0] = "English: Hello World!"; 
messages[1] = "French: Bonjour, le monde!"; 
messages[2] = "Spanish: Hola al mundo"; 
messages[3] = "Klingon: Nuq neH!"; 
messages[4] = "German: Guten Tag, Welt!"; 
messages[5] = "Russian: Zdravstvytye, mir!"; 
messages[6] = "Japan: Sekai e konnichiwa!"; 
messages[7] = "Latin: Orbis, te saluto!"; 

for(t=0;t<NUM_THREADS;t++) { 
    sum = sum + t; 
    thread_data_array[t].thread_id = t; 
    thread_data_array[t].sum = sum; 
    thread_data_array[t].message = messages[t]; 
    printf("Creating thread %d\n", t); 
    rc = pthread_create(&threads[t], NULL, PrintHello, (void *)&thread_data_array[t]); 
    if (rc) { 
    printf("ERROR; return code from pthread_create() is %d\n", rc); 
    exit(-1); 
    } 
    } 
pthread_exit(NULL); 
} 

La pièce ci-dessus code me donne une erreur de segmentation dans Linux en utilisant gcc

En tant que débutant, j'ai quelques questions à l'esprit en ce qui concerne les discussions

1. Si 3 threads sont créés simultanément et si elles doivent quitter, le thread qui est créé en premier est quitté à la fin?
2. Peut-o/p diffèrent chaque fois d'une création de fil et le programme de cessation d'emploi et si oui, pourquoi ?? (je l'ai remarqué qu'ils le font »),

Answer 1

Si 3 threads sont créés simultanément et si ils doivent quitter puis le thread qui est créé en premier est quitté à la fin?

Réponse: il n'y a pas de garantie que le premier thread doit sortir d'abord, une fois créés, ils sont traités comme des entités séparées par le OS et c'est à l'OS de décider ce qui sortira en premier

Est-ce que l'o/p peut différer à chaque fois d'un programme de création et de terminaison de thread et si oui, pourquoi? (J'ai remarqué qu'ils le font);

Réponse: oui ils diffèrent, la raison étant la même que celle expliquée ci-dessus.

Answer 2

Comment et quand chaque thread est programmé est complètement à l'OS. Il n'y a aucun moyen de comprendre cela sans creuser profondément dans le code du système d'exploitation.

Dans la plupart des implémentations de pthreads (je n'ai pas tout utilisé, mais tout ce que j'ai utilisé).
Lorsque le thread principal quitte tous les autres threads, l'exécution s'arrête et l'application se ferme.

Ainsi, avant de quitter le thread principal doit attendre (ou tuer) tous les threads enfants avant de quitter.
Pour cela, nous avons pthread_join().

for(t=0;t<NUM_THREADS;t++) 
{ 
    void* result; 
    pthread_join(threads[t],&result); 
} 
// Now all the children are dead. 

Notez que le système io sous-jacent n'est pas thread-safe.
Ainsi, si plusieurs threads écrivent dans IO, vous risquez d'obtenir un certain entrelacement.

Answer 3

Votre code fonctionne perfectely (je suis également en utilisant gcc) ..

sortie:.

Creating thread 0 
Creating thread 1 
Creating thread 2 
Creating thread 3 
Creating thread 4 
Creating thread 5 
Creating thread 6 
Creating thread 7 
Thread 1: French: Bonjour, le monde! Sum=1 
Thread 0: English: Hello World! Sum=0 
Thread 2: Spanish: Hola al mundo Sum=3 
Thread 4: German: Guten Tag, Welt! Sum=10 
Thread 3: Klingon: Nuq neH! Sum=6 
Thread 5: Russian: Zdravstvytye, mir! Sum=15 
Thread 6: Japan: Sekai e konnichiwa! Sum=21 
Thread 7: Latin: Orbis, te saluto! Sum=28