Discussion :

[Masmeta]

bonjour à tous,
J'ai besoin de votre aide pour prendre du recul sur la création d'une classe concurrentQueue (CQ).
J'essaye de faire des codes d'exemples pour ma classe. Mon erreur n'est pas sur de la compilation ou linkage mais sur du fonctionnel. Mon instance de CQ n'est pas partagé entre mes différents instances utilisateur de CQ.

Voici ma classe de concurrentQueue :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class concurrentQueue
{
    public:
        concurrentQueue(){};
        concurrentQueue(const concurrentQueue& other){
            std::lock_guard<std::mutex> lock(other.mut);
            data_queue = other.data_queue;
        };
        concurrentQueue &operator=(const concurrentQueue &other) = delete;
        virtual ~concurrentQueue(){};
        [....]
};

Je l'utilise de cette façon là :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
 
class Abstraite
{
    public : 
    Abstraite(const concurrentQueue<int>&  aQueue) : myQueue(aQueue){};
    virtual void execute(int number) = 0;
     [...]
};
 
class concreteA : public Abstraite
{
public:    
    concreteA(const concurrentQueue<int>&  aQueue) : myQueue(aQueue){};
    void execute(int number) { int n = number -1; myQueue.push(n); };
    [....]
 
};
 
class concreteB : public Abstraite
{
    public :
    concreteB(const concurrentQueue<int>&  aQueue) : myQueue(aQueue){};
    void execute(int number) { int n = number + 1; myQueue.push(n); }
    [.....]
};
 
class useAandB
{
    public :
    useAandB() {};
    void run();
    [.....]
    private : 
    concreteA A;
    concreteB B;
    concurrentQueue<int> myQueue
}
 
useAandB::useAanB
{
   A = concreteA(myQueue);
   B = concreteB(myQueue);
}
 
useAnB::run()
{
   int number{5};
   A.execute(number);
   B.execute(number);
 
   while(!myQueue.isEmpty)
  {
      int value{0};
      bool try =  myQueue.try_and_pop(value)
      if (try)
          std::cout << value << std:endl;
      else
         std::cout << "Pas de valeur" << std:endl; 
  }
  std::cout << "Fin de lecture" << std::endl;
}
 
 
int main 
{
   useAandB test;
  test.run();
  exit 0;
}

Mon problème est que mes queue dans A et B s’incrémentent indépendamment. Et ma queue dans ma classe useAandB est toujours vide.
J'ai l'impression que mon passage par référence est mal fait.
Quel est votre avis ?

[dalfab]

Bonjour,

Je ne comprends pas bien ce que tu cherches à faire. J'ai l'impression que tu veux une unique file d'attente qui serait partagée par plusieurs instances. Et comme tu parles de 'concurent', ces instances ne seraient pas dans le même thread.
En lisant ton code j'y vois des tas de files d'attentes distinctes. data_queue dans les ConcurentQueue. Dans les Abstraite les Concrete et les useAandB il y a des myQueue qui seraient des ConcurrentQueue. Donc tout ça est distinct et il n'y a donc aucune raison pour qu'une des files d'attente ne soit reliée à une autre.

Peut-être que tu souhaites avoir une seule ConcurrentQueue que les ConcreteA et ConcreteB pourraient utiliser. Ça me parait le plus logique, d'où
- Enlever le constructeur par copie du ConcurrentQueue (comme ça en plus tu ne pourras pas être tenté d'en faire des copies.)
- Abstraite doit stocker un pointeur ou une référence à une ConcurentQueue.
- les Concrete doivent utiliser la ConcurentQueue de leur base Abstraite.

J'ajoute que ton code est bourré de lignes qui ne peuvent pas compiler. J'en corrige quelques une dans cet extrait de code (c'est fait à la volée désolé si j'en ai créées d'autres):

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
class concurrentQueue
{
public:
        concurrentQueue() = default;
        concurrentQueue(const concurrentQueue& other) = delete;
        concurrentQueue &operator=(const concurrentQueue &other) = delete;
        virtual ~concurrentQueue() = default;
        [....]
};
 
class Abstraite
{
public : 
    Abstraite(concurrentQueue<int>& aQueue) : myQueue(aQueue) {}
    virtual void  execute(int) = 0;
     [...]
    concurrentQueue&  theQueue() { return myQueue; }
private:
    concurrentQueue&  myQueue;
};
 
class concreteA : public Abstraite
{
public:
    concreteA(concurrentQueue<int>& aQueue) : Abstraite(aQueue) {}
    void  execute(int number)override { theQueue().push(number -1); };
    [....]
};
 
class concreteB : public Abstraite
{
public:
    concreteB(concurrentQueue<int>& aQueue) : Abstraite(aQueue) {}
    void  execute(int number)override { theQueue().push(number + 1); }
    [.....]
};
 
class useAandB
{
public:
    useAandB();
    void  run();
    [.....]
private:
    concurrentQueue<int>  myQueue; // doit être avant A et B car elles en ont besoin dès leur construction
    concreteA  A;
    concreteB  B;
}
 
useAandB::useAanB() : A{myQueue), B{myQueue} {
}

[Masmeta]

Bonjour Dalfab,

Merci d'avoir pris du temps sur mon problème.
J'ai écrit le code de tête, du coup il est surement non compilable actuellement.

L'idée est d'utiliser ma fifo avec des threads mais avant de valider cette étape, je suis parti sur le principe décrit ci dessus.
La queue doit être commune à l'ensemble des instances.
Je regarde et test ton code.

[Masmeta]

Avec tes précieux conseils, j'ai pu réaliser le fonctionnement que je désirais.
Merci.