Discussion :

[Dalini71]

Bonjour à tous,

Je suis débutant dans le multi-threading en C++11 et j'aurais besoin de quelques conseils pour le cas suivant :

J'ai cette classe :

Code :

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

1
2
3
4
5
6
7
8
9
 
class Toto
{
public:
    // ...
private:
    std::vector<A> a_;
    std::vector<B> b_;
};

Avec a_ et b_ qui vont être accédés (lecture et écriture) en permanence par 2 threads.
Il me semble que la solution classique est d'encapsuler l'accès à ces données dans des méthodes protégées par des std::mutex, mais je trouve cela assez fastidieux.
J'ai vu que std::atomic permet de rendre les opérations sur des données thread-safe, mais ça ne marche que pour les types de base non ?

Merci de me faire profiter de votre expérience pour me dire quelle est la meilleure méthode à adopter ici

[Médinoc]

Les deux threads font-ils tous les deux de l'accès aléatoire en lecture et écriture? Ou bien y a-t-il un motif commun, genre modèle producteur/consommateur?

Aussi, dans certains cas il existe des algorithmes dits "lock-free", qui sont utilisés par exemple dans les "Interlocked singly linked lists" de Windows. Cas algorithmes se basent généralement sur des méthodes atomiques (test-and-set, compare-and-swap) sur des pointeurs ou des paires {pointeur, compteur}.

Si rien de tout ça ne s'applique, j'ai bien peur que tu aies besoin du mutex à un moment où un autre.

[Dalini71]

Un thread fait de la lecture uniquement, l'autre fait lecture/écriture.

Pour les algorithmes "lock-free", je m'étais renseigné sur std::atomic qui a l'air de fonctionner de cette manière, mais de ce que j'ai compris, je suis pas sur que ce soit bien adapter à mon problème.

Est-il possible d'avoir un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
class Toto
{
public:
    // ...
private:
    std::atomic<std::vector<A>> a_;
    std::atomic<std::vector<B>> b_;
};

?

[moham104]

Je crois que si tu trouve que l'utilisation des mutex est fastidieux c'est parce que peut-être tu l'utilise mal. Si à chaque fois que tu veux accéder à ces variables tu les modifie directement ou tu les consulte directement c'est sure et certain que ça peut devenir très lourd.

La meilleur manière serait de créer une fonction pour ajouter, pour supprimer et pour accéder. Ainsi, tu définis ton processus d’accès dans ces fonctions là et ailleurs dans le code tu n'auras pas besoin de t’inquiéter du problème d'interlock.

Voici concrètement ce que je veux dire. Désolé pour l'indentation le copier collé n'a pas très bien marché.

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
 
class Toto
{
public:
    // ...
private:
    std::mutex mutex_a;
    std::mutex mutex_b;
    std::vector<A> a_;
    std::vector<B> b_;
 
	void ajouterDanA(A & obj)
    {
	mutex_a.lock(); 
		a_.push_back(obj);
		mutex_a.unlock();
    }
 
	void supprimerDansA(unsigned int index)
	{
		mutex_a.lock(); 
		a_.push_back(a_.begin()+index);
        mutex_a.unlock();
	}
 
	A consulterA(unsigned int index)
    {
		mutex_a.lock();
		A objet_a = a_[index];
		a_.push_back(a_.begin()+index);
		return objet_a;
	}
 
     // de la même façon pour B
     .....
};

Et dans tes threads tu ne fait qu'utiliser ces fonctions.