Bonjour,

Je cherche a manipuler une liste d’éléments dans deux threads, en donnant la priorité bloquante a l’accès de cette liste a un seul des deux thread.

pour l'instant j'utilisai un mutex, mais cela ne me permet pas de faire ce que je veux.

un peu de code vaut mieux que beaucoup d'explications :

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
 
class Job : public Thread
{
public:
   void run(void)
  {
      while (1)
      {
         m.lock(); // si je veux que l’accès a m_list soit thread safe, je lock, mais cela provoquera un interbloquage quasi permanent
         m_list.push_back(new Item());
         m.unlock(); // si j'ai lock, j'unlock
      }
  }
 
public:
   Mutex m;
   std::vector<Item *> m_list;
};
 
class MainLoop // thread principal, avec une boucle d’évènement que je ne controle pas forcement.
{
   void initialize(void)
   {
       m_pJob = new Job();
       m_pJob->start();
   }
 
   void update(void) // appelé par la boucle d’évènement a une fréquence quelconque
   {
       m_pJob->m.lock();
       while (m_pJob->m_list.size())
       {
           m_list.pop_front();
       }
       m_pJob->m.unlock();
   }
};
C'est très simplifie évidement, mais l’idée est la.
J'ai utilise un std::vector, mais ca aurai très bien pu etre un tableau de pointeur ou n'importe quoi d'autre d’ailleurs, la n'est pas le problème je pense.

Et si je fais comme cela, le main thread n'est pas du tout prioritaire, et va d'ailleurs passer la plus part de son temps a attendre de pouvoir accéder a la liste.

Quelle est la philo générale a adopter si je voulais que le Thread job soit carement bloque des que le main a envie d’accéder a la liste, et jamais l'inverse ?
(si possible sans être lie a une lib ou autre truc non portable)

merci d'avance,