Discussion :

[pier*]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[fearyourself]

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.

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

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

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?

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

Non

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

Oui

Jc

[pier*]

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 ?

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.

[fearyourself]

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.

Dois je me servir des signaux ?

Non

Sinon quelles fonctions utiliser ?

Ce serait ces fonctions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[pier*]

Merci beaucoup pour toutes ces réponses.

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

Jc

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[fearyourself]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Exact

[pier*]

Dernière petite question, je voulais savoir pourquoi on ne peut pas faire ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 void * client(void * arg){
        int sck = (int)*arg;
}

[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