Discussion :

[etherny]

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 :

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
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.

[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.

[etherny]

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 :

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
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);
 
}

[etherny]

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

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
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);
 
}

[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.

[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.