Bonjour,

Je réalise un exercice en multi-threading et  l'objectif serait d'abord d'afficher le contenu d'une file d'attente dans myThread1 mais je n'y arrive pas par contre dans le Main l'affichage fonctionne bien. J'ai l'impression que la file d'attente n'est pas transmise

J'ai fait un fichier main.cpp et ensuite multi_task.h, multi_task.cpp.

le programme principal:

#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif


#include <iostream>
#include <pthread.h>
#include <stdio.h>

#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <mutex>
#include <queue>

#include "multi_task.h"

using namespace std;

 sem_t semaph1, semaph2, semaph3;
 pthread_mutex_t mutex;
 int compt = 0, valeur, tableau[10];
 std::queue<int> myqueue;

int main()
{

    pthread_t tid1, tid2, tid3, tid4, tid5;



//remplissage de la file
    myqueue.push(47);
    myqueue.push(92);
    myqueue.push(137);

/*
    while (!myqueue.empty())
    {
         tableau[0] = myqueue.front();
         myqueue.pop();
        printf("affichage element pile %d \n", tableau[0]);
    }
*/

/*
//affichage de la queue
    while(!myqueue.empty())
    {
        cout << ' ' << myqueue.front() << '\n';
        myqueue.pop();
        cout<<'\n';
    }
*/

//affichage file d'attente
 while(!myqueue.empty())
    {
        printf("%d \n", myqueue.front());
        myqueue.pop();
    }


    printf("Before Thread\n");

    sem_init(&semaph1, 0, 0);
    sem_init(&semaph2, 0, 0);
    sem_init(&semaph3, 0, 0);

//creation du thread
    pthread_create(&tid1, NULL, myThread1, NULL);
    pthread_create(&tid2, NULL, myThread2, NULL);
    pthread_create(&tid3, NULL, myThread3, NULL);
    pthread_create(&tid4, NULL, myThread4, NULL);
    pthread_create(&tid5, NULL, myThread5, NULL);


    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    pthread_join(tid4, NULL);
    pthread_join(tid5, NULL);

    sem_destroy(&semaph1);
    sem_destroy(&semaph2);
    sem_destroy(&semaph3);



//   	freeQueue(queue1);

    printf("After Thread\n");
    return 0;
}

file.h

#ifndef MULTI_TASK_H_INCLUDED
#define MULTI_TASK_H_INCLUDED

extern sem_t semaph1, semaph2, semaph3;
extern pthread_mutex_t mutex;
extern int compt, tableau[10];
extern std::queue<int> myqueue;

void *myThread1(void *vargp);

void *myThread2(void *vargp);

void *myThread3(void *vargp);

void *myThread4(void *vargp);

void *myThread5(void *vargp);

#endif // MULTI_TASK_H_INCLUDED

file.cpp

#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif

#include <iostream>
#include <pthread.h>
#include <stdio.h>

#include <unistd.h>
#include <string.h>
#include <math.h>
#include <semaphore.h>
#include <mutex>
#include <queue>

#include "multi_task.h"

void *myThread1(void *vargp)
{

    sleep(2);
    printf("Thread1 on \n");


    while (!myqueue.empty())
    {
         tableau[0] = myqueue.front();
         myqueue.pop();
        printf("affichage element pile %d \n", tableau[0]);
    }

/*
//affichage de la queue
    while(!myqueue.empty())
    {
        printf("%d \n",myqueue.front());
       myqueue.pop();
    }
*/

/*
//affichage de la queue
    while(!myqueue.empty())
    {
        cout << ' ' << myqueue.front() << '\n';
        myqueue.pop();
        printf("\n");
    }
*/

// incrementation du compteur de semaphore
    sem_post(&semaph1);
    return NULL;
}

 void *myThread2(void *vargp)
{
//attente si compteur de semaphore à 0
    sem_wait(&semaph1);
    sleep(1);
    printf("Thread2 on \n");
    sem_post(&semaph2);
    sem_post(&semaph2);
    sleep(1);
    return NULL;
}

//creation des thread 3 et 4 en même temps après le 2
void *myThread3(void *vargp)
{
    sem_wait(&semaph2);
    sleep(1);
    printf("Thread3 on \n");

    pthread_mutex_lock(&mutex);
     compt++ ;
     if (compt==2)
         sem_post(&semaph3);
    pthread_mutex_unlock(&mutex);

    return NULL;
}

void *myThread4(void *vargp)
{
    sem_wait(&semaph2);
    sleep(2);
    printf("Thread4 on \n");
//cette partie de tâche est bloquée
    pthread_mutex_lock(&mutex);
     compt++ ;
      if (compt==2)
        sem_post(&semaph3);
    pthread_mutex_unlock(&mutex);

    return NULL;
}

//myThread5 s'exécute quand thread 3 et 4 sont arrivés au bout
void *myThread5(void *vargp)
{
    sem_wait(&semaph3);
    compt = 0 ;
    printf("Thread5 on \n");

    return NULL;
}

J'espère que ça ira mieux !

-
Edité par Bernard_A 29 juillet 2019 à 19:09:38

Bonjour,

Attention, ton code mélange allègrement des objets C et des objets C++. Il ne faut pas inclure des fichiers qui se terminent par <.h>.
Je voit mal comment peuvent cohabiter <semaphore.h> avec <mutex> (heureusement à aucun moment tu n'utilises les mutex C++.) En utilisant les objets C++, ça donnerait un code plus robuste et plus simple (c'est l'intérêt du C++ par rapport au C.)

Tu commences par créer une file d'attente de 3 entiers que tu vides immédiatement après!!!
1er thread :
- tu accèdes à la file sans protection (elle est accessible par plusieurs threads risque de data race,) mais il est vrai qu'ils sont tous bloqués sémaphore à cet instant.
- tu écris dans un tableau global, heureusement seul ce thread y accède (du coup à quoi sert-il?)
- tu vides la file (de toute façon elle était déjà vide)
- tu débloques le sémaphore 1.

3ème thread:
- attention utilise un mutex qui n'a jamais été initialisé (les mutex du C ont besoin d'une init contrairement à ceux du C++)

Bonjour,

Je vais réfléchir à ces différentes remarques ; Il est vrai que je suis parti sur du C++ au départ , mais je crois que j'aurais dû utiliser du C , ça fait un peu trop brouillon dans ce projet , le mieux serait que je recommence le tout en C.

 Mon objectif serait que des threads communiquent par files d'attente un peu comme sur Freertos pour le partage de l'acquisition de datas et le traitement .

Pour la programmation des différents threads ce sont des exemples que j'ai pris sur l'Intrenet ici tout n'est qu'un exercice après je verrai pour adapter sur une carte comme Raspberry pi ou Jetson Nano ; Un côté plus pratique dirons-nous.

Merci beaucoup pour la réponse

peut-être @+

Bernard_A a écrit:

Je vais réfléchir à ces différentes remarques ; Il est vrai que je suis parti sur du C++ au départ , mais je crois que j'aurais dû utiliser du C , ça fait un peu trop brouillon dans ce projet , le mieux serait que je recommence le tout en C.

Ou alors tout simplement utiliser les outils fournis par C++ qui sont beaucoup plus facile à utiliser et standards, contrairement à pthread.