Synchro Thread et Vecteur

Version imprimable

Bonjour,
Je cherche à utiliser des vecteurs dans des thread différents et je rencontre des problème d'accès à la mémoire. Voici mon code :

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
#include <iostream>
#include <sstream>
#include <windows.h>
#include <vector>
 
int sortie=0;
 
std::vector <int>	monVecteur(0);
std::vector <int>	monVecteurCopy(0);
 
DWORD WINAPI thread1(LPVOID lpParameter)
{
	while (sortie==0)
    {
		monVecteur.push_back(10);
	}
	return 0;
}
 
DWORD WINAPI thread2(LPVOID lpParameter)
{
	while (sortie==0)
    {
		monVecteurCopy.clear();
		for(int i=0;i<monVecteur.size();i++)
		{
			monVecteurCopy.push_back(monVecteur.at(i));
		}
	}
	return 0;
}
 
int main()
{
 
	DWORD threadID;
	CreateThread(NULL, 0, thread1, NULL, 0, &threadID);
	DWORD threadID2;
	CreateThread(NULL, 0, thread2, &monVecteur, 0, &threadID2);
 
	std::cin>>sortie;
 
	Sleep(1000);
}

Merci pour votre réponse.

27/12/2007, 22h24
Médinoc
1. Ben, ça dépend de ce que tu veux faire: Si tu veux faire un truc de type producteur/consommateur, tu devrais utiliser un sémaphore par exemple...
2. Tu utilise les classes de la STL, aussi je te conseille d'utiliser _beginthreadex() (déclarée dans process.h) plutôt que CreateThread. Attention, pour _beginthreadex(), le type de retour devra être UINT et non DWORD.

Mon problème

Mon problème est le suivant je souhaite que certains Thread accèdent à un vecteur en lecture seule mais ce vecteur peut être modifié en cours de route par un autre Thread qui lui est en écriture seule. Est-ce possible ?

PS : j'ai fais l'essai avec beginthreadex ca fait la même chose plantage dans premières secondes.

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
#include <iostream>
#include <stdlib.h>
#include <windows.h>
#include <process.h>
#include <sstream>
#include <vector>
 
 int sortie=0;
 
std::vector <int>	monVecteur(0);
std::vector <int>	monVecteurCopy(0);
 
DWORD WINAPI thread1(LPVOID lpParameter)
{
	while (sortie==0)
    {
		monVecteur.push_back(10);
	}
	return 0;
}
 
DWORD WINAPI thread2(LPVOID lpParameter)
{
	while (sortie==0)
    {
		monVecteurCopy.clear();
		for(int i=0;i<monVecteur.size();i++)
		{
			monVecteurCopy.push_back(monVecteur.at(i));
		}
	}
	return 0;
}
 
 
int main()
 
{
 
	HANDLE hThrd1;
	HANDLE hThrd2;
	DWORD threadID;
 
	hThrd1 = (HANDLE) _beginthreadex(
                                    0,0,
            (unsigned (_stdcall *)(void *)) thread1,
            (LPVOID) 0,0,  (unsigned *) &threadID
           );
 
	hThrd2 = (HANDLE) _beginthreadex(
                                    0,0,
            (unsigned (_stdcall *)(void *)) thread2,
            (LPVOID) 0,0,  (unsigned *) &threadID
           );
 
	std::cin>>sortie;
 
	Sleep(1000);
 
 
   return(0);
 
}

Je suis sur une piste

Je pense pouvoir m'en sortie avec les zones critiques :

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
71
72
#include <iostream>
#include <stdlib.h>
#include <windows.h>
#include <process.h>
#include <sstream>
#include <vector>
#include <stdio.h>
#include <conio.h>
 
int sortie=0;
CRITICAL_SECTION Sync;
 
std::vector <int>	monVecteur(0);
std::vector <int>	monVecteurCopy(0);
 
DWORD WINAPI thread1(LPVOID lpParameter)
{
	while (sortie==0)
    {
		EnterCriticalSection(&Sync);
		monVecteur.push_back(10);
		LeaveCriticalSection(&Sync);
	}
	return 0;
}
 
DWORD WINAPI thread2(LPVOID lpParameter)
{
	while (sortie==0)
    {
		EnterCriticalSection(&Sync);
		monVecteurCopy.clear();
		for(int i=0;i<monVecteur.size();i++)
		{
			monVecteurCopy.push_back(monVecteur.at(i));
		}
		LeaveCriticalSection(&Sync);
	}
	return 0;
}
 
 
int main()
 
{
	InitializeCriticalSection(&Sync);
 
	HANDLE hThrd1;
	HANDLE hThrd2;
	DWORD threadID;
 
	hThrd1 = (HANDLE) _beginthreadex(
                                    0,0,
            (unsigned (_stdcall *)(void *)) thread1,
            (LPVOID) 0,0,  (unsigned *) &threadID
           );
 
	hThrd2 = (HANDLE) _beginthreadex(
                                    0,0,
            (unsigned (_stdcall *)(void *)) thread2,
            (LPVOID) 0,0,  (unsigned *) &threadID
           );
 
	std::cin>>sortie;
 
	Sleep(1000);
 
	DeleteCriticalSection(&Sync);
 
	return(0);
 
}

28/12/2007, 10h20
Médinoc
Bonjour,
1. Jamais de cast sur les pointeurs de fonction. Change leur type de retour en UINT et supprime ces casts hideux.
2. En effet, la section critique est nécessaire pour empêcher une tentative de lecture pendant une réallocation. Si la taille maximale du vecteur était fixée à l'avance, il n'y aurait pas de réallocation et on pourrait se passer de la section critique.
28/12/2007, 11h00
NiamorH

Perso, pour un ancien projet, j'avais fait une classe FileSecurisee qui s'occupait à ma place de la section critique et de la std::deque. Je faisais mes appels Empiler( obj ) et Defiler() de maniere transparente.

Il y avait un thread pour extraire les objets et 1..n thread(s) pour les insertions.
28/12/2007, 11h09
etherny

Anout cast hideux

C'est remoi :)
Merci pour vos conseilles en effet c'est pas top les cast, c'est un code que j'ai récupéré sur le net pour les beginthreadex mais je suis resté avec le createthread et les zone critiques cela fonctionne correctement.

Mes tableaux sont dynamiques (vecteurs) et augmentent et diminues dans le temps ce qui ne me permet pas d'allouer la place nécessaire au depart de l'application sachant surtout que je ne connais pas par avance la longeur du tableau. De plus les thread sont très rapides 30 ms pour le plus lent, j'ai donc besoin d'un processus de synchronisation (ou de blacage) des ressources rapide et fiable.

Je parts donc sur les zones critiques mais si vous avez d'autres solutions je suis à votre écoute. Je ne peux pas utiliser les sémaphores car les accès doivent être sans interruption et sans blocage des ressources (a moins que je n'ai pas pigé le fonctionnement des sémaphores).

Sur ce merci pour votre aide !

Tu n'as en effet pas bien compris le principe des sémaphores, mais de toute façon la façon dont je pensais les utiliser ne marcherait pas ici car aucune lecture ne peut être garantie lors d'une écriture (à cause de la réallocation).

Ton code revu et corrigé:

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
71
72
73
74
75
76
77
78
#include <windows.h>
#include <process.h>
#include <iostream>
#include <vector>
 
//Ajout du qualificateur volatile.
volatile int sortie=0;
CRITICAL_SECTION Sync;
 
std::vector <int> monVecteur(0);
std::vector <int> monVecteurCopy(0);
 
//Type de retour changé en UINT
UINT WINAPI thread1(LPVOID lpParameter)
{
	while (sortie==0)
	{
		EnterCriticalSection(&Sync);
		monVecteur.push_back(10);
		LeaveCriticalSection(&Sync);
	}
	return 0;
}
 
//Type de retour changé en UINT
UINT WINAPI thread2(LPVOID lpParameter)
{
	while (sortie==0)
	{
		EnterCriticalSection(&Sync);
		monVecteurCopy.clear();
		//Type changé en size_t
		for(size_t i=0;i<monVecteur.size();i++)
		{
			monVecteurCopy.push_back(monVecteur.at(i));
		}
		LeaveCriticalSection(&Sync);
	}
	return 0;
}
 
//Le main.
int main(void)
{
	InitializeCriticalSection(&Sync);
 
	HANDLE hThrd1;
	HANDLE hThrd2;
	//Type changé en UINT pour l'ID aussi.
	UINT threadID;
 
	hThrd1 = (HANDLE) _beginthreadex(
	 0, 0,
	 thread1,
	 NULL, 0, &threadID
	 );
 
	hThrd2 = (HANDLE) _beginthreadex(
	 0,0,
	 thread2,
	 NULL, 0, &threadID
	 );
 
	char dummy;
	std::cin>>dummy;
	sortie = 1;
 
	//Remplacement de Sleep(1000); par une vraie attente
	WaitForSingleObject(hThrd1, INFINITE);
	WaitForSingleObject(hThrd2, INFINITE);
 
	//Ajout de CloseHandle une fois les threads terminés
	CloseHandle(hThrd1);
	CloseHandle(hThrd2);
	DeleteCriticalSection(&Sync);
 
	return(0);
}

28/12/2007, 12h44
JolyLoic

Citation:

Envoyé par etherny

Je parts donc sur les zones critiques mais si vous avez d'autres solutions je suis à votre écoute. Je ne peux pas utiliser les sémaphores car les accès doivent être sans interruption et sans blocage des ressources (a moins que je n'ai pas pigé le fonctionnement des sémaphores).

Et comment crois-tu que fonctionnent les sections critiques, si ce n'est en bloquant l'accès ?

Si tu as vraiment besoin d'algorithme sans blocage, il en existe (au prix d'une complexité et d'un temps processeur plus importants). Tu peux rechercher lock-free sur google, ou peut-être utiliser une des conteneurs des tbb (http://threadingbuildingblocks.org/ ).