création de plusieurs processus

[invitee2f3230c]

Bonjour
j'ai à faire un programme qui doit créer n thread , n donnée par l'utilisateur, chaque thread afficher son tid.
facile
moi, je me bloque au niveau de la variable :
pthread_t th;
comment peux-je la généraliser ?
le probléme que à chaque thread crée on attribue un variable pour lui seulement.
bin, voilà mon essai cas même :

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

void * fct (void* arg)
{
     pid_t tid=syscall(__NR_getpid)
     printf("mon tid est: %d \n",tid);
     sleep(10);
     return 0;
}
int main()
{
     int i,n;
     printf("taper n \n");
     scanf("%d",&n);
     for(i=1;i<=n;i++)
     {
         pthread_t th;
         //on cree le proc
         pthread_create(&th,NULL,&fct,NULL);
    }
    return 0;
}

le programme s’exécute correctement sauf qu'il crée un seul thread !!
je pense que le problème vient de la variable "th", mais comment pourrai-je créer n variable de ce type?!!

alors qui peut svp
-----

[Jack]

Je ne comprends pas. Ton programme crée n threads. Il suffit de mémoriser leur ID renvoyé par chaque appel à pthread_create.

A+

[doul11]

Bonsoir,

je ne suis pas sur, mais en dehors de la boucle for tu fait

pthread_t *th;

th=malloc(sizeof(th)*n);

dans la boucle for

pthread_create(&th[i],NULL,&fct,NULL);

[Jack]

Bonne idée doul11.

Ce que je trouve bizarre dans le programme, c'est le sleep(10) dans la fonction de thread. La fonction main sera terminée avant que les 10 secondes ne soient écoulées. Le threads seront donc terminés par la même occasion.

Pour que les threads puissent se terminer, il faudrait synchroniser avec un phtread_join().

A+
[FONT=&quot] [/FONT]

[A voir en vidéo sur Futura]

[invitee2f3230c]

merci pour vos réponses.
en utilisant la solution indiquée par doul11, ca a marché sauf que les
thread crée on le même pid, c'est normal ou bien c'est à dire que le 1 thread se repéte ?
bon voilà le code :

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<yscall.h>
#include<malloc>
void * fct (void* arg)
{
     pid_t tid=syscall(__NR_getpid)
     printf("mon tid est: %d \n",tid);
     sleep(10);
     return 0;
}
int main()
{
     int i,n;
     printf("taper n \n");
     scanf("%d",&n);
     pthread_t *threads;
     threads=malloc(sizeof(threads)*n);
     for(i=1;i<=n;i++)
     {
         
         pthread_create(&th[i],NULL,&fct,NULL);
    }
    return 0;
}

est ce que le n à une limite,si oui comment peux-je savoir ? (je pense que c'est à l'aide de : PTHREAD_THREADS_MAX)

Amicalement

[invitee2f3230c]

Pour que les threads puissent se terminer, il faudrait synchroniser avec un phtread_join().

mais les threads termineront dés que la fct termine, non?
d'aprés ce que j'ai du cours, phtread_join() sert à : le pere de ce thread va attendre sa fin.

[Jack]

         pthread_create(&th[i],NULL,&fct,NULL);

??? Il est déjà étonnant que ça compile.

C'est plutôt

         pthread_create(&threads[i],NULL,&fct,NULL);

les
thread crée on le même pid, c'est normal ou bien c'est à dire que le 1 thread se repéte ?

Bin oui c'est normal, puisque les threads s'exécutent (théoriquement) au sein d'un même processus. Donc tous tes getpid renvoient la même valeur, celle du processus de ton programme.
En réalité, sous linux et contrairement à UNIX, les threads s'exécutent dans des processus, mais on va dire que c'est masqué par la gestion des threads linux.

Tu as pourtant du te rendre compte que tes threads ne faisaient pas la tempo de 10 s. Là aussi c'est normal car le main s'est terminé, donc le processus, donc les threads avec.

A+

[invitee2f3230c]

bon , j'ai commue une erreur :
au lieu de gettid j'ai écrit getpid et c'est normale d'avoir le même pid => même processus

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<yscall.h>
#include<malloc>
void * fct (void* arg)
{
     pid_t tid=syscall(__NR_gettid)
     printf("mon tid est: %d \n",tid);
     sleep(10);
     return 0;
}
int main()
{
     int i,n;
     printf("taper n \n");
     scanf("%d",&n);
     pthread_t *threads;
     threads=malloc(sizeof(threads)*n);
     for(i=1;i<=n;i++)
     {
         
         pthread_create(&th[i],NULL,&fct,NULL);
    }
    return 0;
}

merci à tous ce qui m'ont aidé

[invitee2f3230c]

bon, ce que je ne comprend c'est pourquoi vous me conseillez l'ajout d'un phtread_join() dans le programme?
si j'ai bien raison c'est pour évite que le processus père laisse ses threads orphelins, non?

[invitee2f3230c]

SVP, quelle est la valeur max que "n" ne doit pas dépasser ?
c'est 2000,n'est ce pas ?

[Jack]

bon, ce que je ne comprend c'est pourquoi vous me conseillez l'ajout d'un phtread_join() dans le programme?
si j'ai bien raison c'est pour évite que le processus père laisse ses threads orphelins, non?

Il n'y a PAS de thread orphelin comme je te l'ai dit par 2 fois déjà: les threads se terminent en même temps lorsque le return de la fonction main est atteint, ce qui termine le processus. Et comme tous les thread appartiennent au même processus ...

pthread_join permet d'attendre la fin d'un ou de tous les threads, évitant ainsi au processus de se terminer avant que les threads aient terminé leur travail.

A+