Questions relatives au fonctionement des threads

Version imprimable

Bonjour,

Je developpe un proxy HTTP et j'utilise donc les threads pour gérer les connexions de chaque client. J'utilise phtread et je suis sous unix.Avant tout voici un bout de code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void * client(void * arg){ int sck; memcpy(&sck,arg,1); printf("sck %d\n",sck); pthread_exit(0); } main(){ while(1){ sckClient = sckAccept(,,); pthread_create(&th,NULL,client,(int*)&sckClient); } }
Pensez vous qu'il est nécessaire de verouiller la variable sckClient dans le main juste aprés pthread_create puis de la déverouiller dans la fonction client juste après le memset ?
Ceci afin de s'assurer que c'est la bonne valeur de l'id de la socket qui est copié.
Mais cela ne coserai t il pas un probléme si aprés avoir vérouiller le socket en ecriture, une demande accept retourne immédiatement avant que le memset de la fonction client est eu lieu ?
Personellement j'ai laisser tourner mon code en boucle en remplacant le main par ceci :
Code:

1 2 3 4 5 6 7 8 main(){ while(1){ sckClient = 15; pthread_create(&th,NULL,client,(int*)&sckClient); sckClient = 1; } }
Le thread m'a toujours affiché la valeur 15 et jamais la valeur 1.

Deuxiéme question : pourquoi est t on obligé de passer le paramètre de la fonction client par adresse dans pthread_create ? (Oui je sais que client(void *) et pthread_create(,,,void **) mais pourquoi ? )

Et enfin sommes nous obligé de faire un appel a pthread_exit à la fin de la fonction client. N'est il pas appelé automatique lorsque le programme atteint la fin de la fonction ?

24/05/2006, 14h22
fearyourself

Citation:

Envoyé par pier*

Pensez vous qu'il est nécessaire de verouiller la variable sckClient dans le main juste aprés pthread_create puis de la déverouiller dans la fonction client juste après le memset ?

Oui mais pas forcément comme cela, il faut endormir le thread principal avec une condition pour donner le temps au fils de lire la donnée. Ensuite, l'autre thread peut réveiller le père quand la lecture est faite.

Plus simple, allouée une zone mémoire pour le nouveau thread, y mettre l'information et le thread créé peut libérer la mémoire lorsque c'est nécessaire.

Citation:

Le thread m'a toujours affiché la valeur 15 et jamais la valeur 1.

Il suffit d'une fois et c'est fini...

Citation:

Deuxiéme question : pourquoi est t on obligé de passer le paramètre de la fonction client par adresse dans pthread_create ? (Oui je sais que client(void *) et pthread_create(,,,void **) mais pourquoi ? )

Tu aurais fait comment toi?

Citation:

Et enfin sommes nous obligé de faire un appel a pthread_exit à la fin de la fonction client.

Non

Citation:

N'est il pas appelé automatique lorsque le programme atteint la fin de la fonction ?

Oui

Jc
24/05/2006, 18h18
pier*

Citation:

Envoyé par fearyourself

Oui mais pas forcément comme cela, il faut endormir le thread principal avec une condition pour donner le temps au fils de lire la donnée. Ensuite, l'autre thread peut réveiller le père quand la lecture est faite.

Ok cette méthode me parait beaucoup plus adapté. Peux tu me donner plus de détail ? Dois je me servir des signaux ? Sinon quelles fonctions utiliser ?

Citation:

Envoyé par fearyourself

Plus simple, allouée une zone mémoire pour le nouveau thread, y mettre l'information et le thread créé peut libérer la mémoire lorsque c'est nécessaire.

J'ai pas compris, je ne vois pas ce que cela pourrai changer quant à la protection de l'écrasement de la donnée pas le main.

Citation:

Envoyé par pier*

Ok cette méthode me parait beaucoup plus adapté. Peux tu me donner plus de détail ?

Oui si tu ne trouves pas que la 2ème méthode est plus simple.

Citation:

Dois je me servir des signaux ?

Non

Citation:

Sinon quelles fonctions utiliser ?

Ce serait ces fonctions :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
       #include <pthread.h>

       pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

       int  pthread_cond_init(pthread_cond_t  *cond, pthread_con*
       dattr_t *cond_attr);

       int pthread_cond_signal(pthread_cond_t *cond);

       int pthread_cond_broadcast(pthread_cond_t *cond);

       int        pthread_cond_wait(pthread_cond_t         *cond,
       pthread_mutex_t *mutex);

       int      pthread_cond_timedwait(pthread_cond_t      *cond,
       pthread_mutex_t *mutex, const struct timespec *abstime);

       int pthread_cond_destroy(pthread_cond_t *cond);

Citation:

J'ai pas compris, je ne vois pas ce que cela pourrai changer quant à la protection de l'écrasement de la donnée pas le main.

Toi tu fais comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void * client(void * arg){
        int sck;
        memcpy(&sck,arg,1);
        printf("sck %d\n",sck);
        pthread_exit(0);
}
 
 
main(){
        while(1){
                sckClient = sckAccept(,,);
                pthread_create(&th,NULL,client,(int*)&sckClient);
                }
      }

Moi je dis de faire comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
void * client(void * arg){
        int sck, *p_sck;
        p_sck = arg;
        if(p_sck)
         {
         sck = *p_sck;
         free(p_sck);
         printf("sck %d\n",sck);
         }
}
 
main(){
       int *p;
 
        while(1){
                sckClient = sckAccept(,,);
                p = malloc(sizeof *p);
                if(p==NULL)
                 {
                 /*Gestion de l'erreur*/
                 }
                *p = sckClient;
 
                pthread_create(&th,NULL,client,p);
                }
      }

Comme cela, tu alloues une zone spécifique pour chaque thread qui le libére lorsqu'il le faut... Plus besoin de condition, d'endormir, etc.

Par contre, étudie memcpy, tu le faisais mal...

Jc

24/05/2006, 19h43
pier*

Merci beaucoup pour toutes ces réponses.

Citation:

Envoyé par fearyourself

Par contre, étudie memcpy, tu le faisais mal...

Jc

oui je suppose que tu voulais dire qu'il fallait faire :

Code:

memcpy(&sck,arg,sizeof(int));
24/05/2006, 19h45
fearyourself

Citation:

Envoyé par pier*

oui je suppose que tu voulais dire qu'il fallait faire :

Code:

memcpy(&sck,arg,sizeof(int));

Exact
24/05/2006, 21h22
pier*
Dernière petite question, je voulais savoir pourquoi on ne peut pas faire ca :
Code:

1 2 3 void * client(void * arg){ int sck = (int)*arg; }
24/05/2006, 22h11
fearyourself

Si tu es en train de demander pourquoi cela ne passe pas à la compilation alors la réponse est :

on ne peut pas utiliser la donnée qui se trouve dans une zone pointée par un pointeur void puisqu'on ne sait pas ce qu'il y a dedans...

Jc