Utilisation d'une concurrent queue

Version imprimable

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:

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:

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 ?

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:

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} { }

04/01/2021, 11h06
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.
04/01/2021, 11h59
Masmeta

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