Comment synchoniser deux threads ?

**Jayceblaster** · 28/03/2007, 19h03

Bonjour a tous...

Je connais pas bien les threads et je rame un peu.
J'ai deux threads (tread1 et thread2) qui utilise la meme variable...Thread1 écrit la variable et thread2 lit cette variable...
Le problème c'est que je veux etre sur que thread1 a mis à jour la variable quand thread2 l'utilise...
Globalement peut-on synchroniser deux threads?

Merci d'avance pour l'aide

**granquet** · 28/03/2007, 19h32

Globalement, oui.
avec des mutex.

http://emmanuel-delahaye.developpez.com/pthreads.htm

**mchk0123** · 28/03/2007, 23h05

Tu as également la notion de "critical section" (si tes threads sont tous dans le même processus).

**ViRouF** · 29/03/2007, 09h22

Ne peut-il pas le faire avec des pipes tout simplement ?

**mchk0123** · 29/03/2007, 09h57

Une fois que l'on à compris le principe, les mutex et les critical section ne sont pas plus compliqués à utiliser que des pipes.

C'est vrai que le pipes (ainsi que plein d'autres mécanismes RPC) peuvent être utilisés ici, mais ce n'est pas leur vocation première : transfert de données volumineuses entre processus sans stockage disque.

**Médinoc** · 29/03/2007, 09h57

La section critique (ou le mutex) servent à empêcher qu'une variable soit modifiée pendant qu'elle est lue, ou qu'elle soit modifiée par plusieurs threads en même temps.

J'ai plutôt l'impression que Jayceblaster cherche à faire un modèle producteur/consommateur : Là, un tube (ou un/deux sémaphore(s) + un buffer circulaire) seraient plus appropriés...

**mchk0123** · 29/03/2007, 10h55

Oui, pas mal ...

Et que dis tu d'une simple variable globale partagée, + pour la synchronisation :

- events (sous Windows) ou signaux (sous Linux)
- WaitForSingleObject (sous Windows) ou ??? je sais plus* ??? (sous Linux)

* : un handler peut-être ?

**femtosa** · 29/03/2007, 11h20

Un simple sémaphore initialisé à '0' ferait très bien l'affaire pour synchroniser deux tâches ...

Un mutex ne garantira pas que la variable a été initialisée ...

**GyZmoO** · 29/03/2007, 11h51

Oui un sémaphore avec au départ le jeton pour le thread qui doit écrire et voilou . . .

**Médinoc** · 29/03/2007, 11h52

Si c'est juste pour l'initialisation, il suffit de créer un mutex et le bloquer avant de créer le second thread, puis le relâcher une fois la variable initialisée...

En fait, pour prendre une décision il faut savoir avec certitude s'il doit y avoir UNE écriture ou N écritures...

**mchk0123** · 29/03/2007, 13h58

Les mutex ont l'avantage d'exister sur Linux comme sur Windows ; alors qu'à ma connaissance, les sémaphores n'existent pas sur Windows.

**Médinoc** · 29/03/2007, 14h29

Et pourtant si, ils existent.
Leur problème est qu'on ne peut pas récupérer plus d'une unité à la fois par sémaphore (mais on peut attendre sur plusieurs sémaphores en même temps).

**Jayceblaster** · 29/03/2007, 15h01

salut a tous
merci pour toutes ces reponse mais la je ne comprend pas ... un exemple peut etre?

Merci a tous

**hegros** · 29/03/2007, 16h15

Envoyé par Jayceblaster

salut a tous
merci pour toutes ces reponse mais la je ne comprend pas ... un exemple peut etre?

Merci a tous

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
1-créer un mutex
 
Mutex M = CreateMutex();
 
2-lancer les threads
 
 
Function Thread1
 
M.Lock()
//traitement
M.Unlock()
 
Function Thread2
 
M.Lock()
//traitement
M.Unlock()
 
Function ThreadN
 
M.Lock()
//traitement
M.Unlock()