IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Threads & Processus C++ Discussion :

Un seul thread fonctionnant dans un programme multithreadé (avec threads dans thread)


Sujet :

Threads & Processus C++

  1. #1
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2014
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2014
    Messages : 26
    Points : 11
    Points
    11
    Par défaut Un seul thread fonctionnant dans un programme multithreadé (avec threads dans thread)
    Bonjour,

    Je rencontre un problème lors de l'éxecution de mon programme multithreadé. Donc en fait j'ai une boucle for qui créée n threads et ensuite ces n threads créés chacun 2 nouveaux threads. Finalement, j'ai donc 2*n threads qui doivent fonctionner en même temps.

    Je peux voir dans mon programme que les n couples de threads sont bien créés, mais aussi qu'après leurs créations que seulement le dernier thread créé tourne. Les n-1 premiers couples de threads font rien et reste bloqués.

    J'ajoute que mon programme est supposé tourné à l'infini (while(1) pour l'envoi et la réception de messages dans les threads 1 et 2) et donc que les n threads créés dans la boucle for ne doivent jamais se terminer normalement.

    Voici à quoi ressemble mon 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
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
     
    void *thread1_send (void * arg_threads)
    {  
        // do some work
     
        pthread_exit (0);
    }
     
    void *thread2_listen (void * arg_threads)
    {
        // do some work
     
        pthread_exit (0);
    }
     
     
    void *thread_multi (void * arg_threads)
    {
        // first thread
        if (pthread_create (&th1, NULL, thread1_send, arg_threads) < 0) {   
            printf ("Error pthread_create for thread 1\n");
            exit (1);
        }
     
        //second thread
        if (pthread_create (&th2, NULL, thread2_listen, arg_threads) < 0) {   
            printf ("Error pthread_create for thread 2\n");
            exit (1);
        }
     
        (void)pthread_join (th1, &ret_t);
        (void)pthread_join (th2, &ret_t);
     
        pthread_exit(0);
    } 
     
     
     
    pthread_t * th_multi = (pthread_t *) malloc( n * sizeof(*th_multi) );
    ....
    ....
    // for loop in a function
    for(int i=0; i<n; i++)
    {                                                                              
        // creation of n threads
        if (pthread_create (&th_multi[i], NULL, thread_multi, arg_threads) < 0) {   
            printf ("Error pthread_create for thread_multi [%d].\n", i);
            exit (1);
        }
    } 
     
    for(int j=0; j<n; j++)
    {
    	    (void)pthread_join (th_multi[j], &ret_t);
    }

  2. #2
    Membre expérimenté Avatar de Trademark
    Profil pro
    Inscrit en
    Février 2009
    Messages
    762
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2009
    Messages : 762
    Points : 1 396
    Points
    1 396
    Par défaut
    Il faudrait voir ce qu'il y a dans thread1_send et thread2_listen. Par contre ce que tu nous montres là est du C donc il est préférable que tu ailles dans cette catégorie. En C++, préfère l'utilisation de std::thread.

  3. #3
    Expert confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2012
    Messages
    1 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2012
    Messages : 1 711
    Points : 4 442
    Points
    4 442
    Par défaut
    Hello,

    C'est du C, pas du C++.

    Tu ne crée pas 2*n thread, mais 3*n threads.

    En C++, celà ressemblera plus à ça :
    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
    // il faudra prévoir un moyen de les stopper proprement.
    void threadSend(int i, int j) {
    	while(1) {
    		std::cout << "send : " << i*j << std::endl;
    		std::this_thread::sleep_for(std::chrono::seconds(1));
    	}
    }
     
    // exemple sans arguments
    void threadListen() {
    	while(1) {
    		std::cout << "listen : " << std::this_thread::get_id() << std::endl;
    		std::this_thread::sleep_for(std::chrono::seconds(1));
    	}
    }
     
    std::vector<std::thread> threads;
    threads.reserve(n);
    for(int i=0; i<n; ++i) {
    	threads.emplace_back(threadSend, i, 12);
    	threads.emplace_back(threadListen);
    }
    for(auto &t : threads) {
    	t.join();
    }
    Mais à part les return manquant dans "thread1_send" et "thread2_listen" et l'utilisation de malloc (!!) je ne vois pas de problèmes.

  4. #4
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2014
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2014
    Messages : 26
    Points : 11
    Points
    11
    Par défaut
    Citation Envoyé par Trademark Voir le message
    Il faudrait voir ce qu'il y a dans thread1_send et thread2_listen. Par contre ce que tu nous montres là est du C donc il est préférable que tu ailles dans cette catégorie. En C++, préfère l'utilisation de std::thread.
    Voilà le code dans thread1_send et thread2_listen :
    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
     
    void *thread1_send(void * arg_threads)
    {	
    	ARG_THREADS * s_arg_th = (ARG_THREADS*) arg_threads;
     
            Envoi envoi;
     
            envoi.send(s_arg_th);  
     
    	pthread_exit (0);
    }
     
    void *thread2_listen(void * arg_threads)
    {
    	ARG_THREADS * s_arg_th = (ARG_THREADS*) arg_threads; 
     
            Ecoute ecoute;
     
            ecoute.listen(s_arg_th); 
     
    	pthread_exit (0);
    }
    Je viens de penser à la réentrance. ça pourrait poser un problème ici avec les classes Envoi et Ecoute ?

  5. #5
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2014
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2014
    Messages : 26
    Points : 11
    Points
    11
    Par défaut
    Pour avancer j'ai essayé de debugger le programme avec des printf partout (printf("%i: at line %s:%i\n", (int) pthread_self(), __FILE__, __LINE__); ). J'ai pas trouvé de meilleur moyen que ça.

    Donc en fait j'ai les (n-1) premiers threads, ceux qui sont censés envoyer les messages, qui ne se réveillent jamais après un sleep() que j'utilise dans ce thread. Tandis que dans le même temps les (n-1) autre threads, du même couple, chargés eux d'écouter les messages entrant tournent mais ne reçoivent rien. Et je peux voir que le dernier des n threads créés lui se réveille bien après le premier sleep et continue d'envoyer et recevoir normalement.

    Je pense donc que le problème viendrait de sleep(). On peut pas l'utiliser dans des programmes multithreads ? Il y a des alternatives si ça fonctionne pas avec ?

  6. #6
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 627
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 627
    Points : 10 548
    Points
    10 548
    Par défaut
    Es-tu sûr que le sleep n'est pas sur le thread principal?

    Parce que avec boost on code comme cela
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    boost::this_thread::sleep( boost::posix_time::milliseconds(IDLE_TIME) );

  7. #7
    Membre à l'essai
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2014
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2014
    Messages : 26
    Points : 11
    Points
    11
    Par défaut
    A priori non, normalement le sleep ne doit affecter que le thread dans lequel je l'utilise. A savoir le thread1_send dans la fonction send() de la classe Envoi (cf. plus haut).
    Avec les printf je constate bien que ce sont mes n threads que j'ai créé qui sont bien endormis.

Discussions similaires

  1. Réponses: 7
    Dernier message: 23/10/2012, 18h17
  2. Réponses: 7
    Dernier message: 06/02/2012, 11h04
  3. Réponses: 2
    Dernier message: 11/12/2007, 09h38
  4. Réponses: 4
    Dernier message: 02/05/2007, 17h18
  5. Réponses: 0
    Dernier message: 08/12/2005, 22h39

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo