Thread Synchronisation avec structure FIFO ??

Version imprimable

28/03/2006, 12h06
vincedom

Thread Synchronisation avec structure FIFO ??

Bonjour j'ai creer un prog multiThread en C++ sous Visual .Net 2003 avec MFC. Bien entendu j'ai des problemes de concurrence d'acces entre mes threads que j'ai resolus grace a une CCriticalSection. Mais vraisemblablement la CCriticalSection utilise une stack :( (structure LIFO) pour la file d'attente, or moi je voudrai qqch qui utilise une queue (structure FIFO): pour eviter qu'une des mes 4 threads soit quasi bloquee... J'ai beau chercher sur la msdn, sur developpez.com, et sur Internet en general: je trouve pas :cry: !!

Merci par avance pour votre aide :wink:
28/03/2006, 22h27
mat.M

Re: [MFC] Thread Synchronisation avec structure FIFO ???

Citation:

Envoy� par vincedom

Bonjour j'ai creer un prog multiThread en C++ sous Visual .Net 2003 avec MFC. Bien entendu j'ai des problemes de concurrence d'acces entre mes threads que j'ai resolus grace a une CCriticalSection. Mais vraisemblablement la CCriticalSection utilise une stack :( (structure LIFO) pour la file d'attente, or moi je voudrai qqch qui utilise une queue (structure FIFO): pour eviter qu'une des mes 4 threads soit quasi bloquee... J'ai beau chercher sur la msdn, sur developpez.com, et sur Internet en general: je trouve pas :cry: !!

Merci par avance pour votre aide :wink:

Impossible il me semble
Ou alors modifier le code source des MFC ( attention: lier les MFC de mani�re statique ) ou au mieux ne pas utiliser CCriticalSection mais DIRECTEMENT avec les API comme EnterCriticalSection :wink:
29/03/2006, 04h15
vincedom

Salut

Je me fiche d'utiliser MFC ou directement les API Windows. J'ai regarde un peu les differents Semaphores, Moniteurs et autres Mutex MFC et j'ai rien trouve :cry:... Mais de toute facon je suis pas sur que ca change des masses vu que par exemple une CCriticalSection c juste un petit mappage d'une CRITICAL_SECTION. :?
Mais il doit qu'en meme bien y avoir un truc tout fait qui te permet de faire un synchronisation avec une structure LIFO :?: Ca parait bien plus normal de faire de la synchro avec du LIFO qu'avec du FIFO.

Citation:

:ange: les premiers seront les derniers :ange:

Mais qu'en meme :!: :!:

Les sections critiques ne permet seulement d'executer une partie du code d'un programme sans chang� de thread.
Si differant thread accede a une ressource partage, proteg� par une section critique, le premier accede a celle-ci, mais les suivants son bloqu� jusqu'a la liberation de celle-ci. Ce qui suit une FIFO (le premier entr� sera le premier sortie).
Voici un programme de test utilisant API windows CRITICAL_SECTION, (Normalement identique au MFC)

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
// CritcalSection.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include "windows.h"
 
class CriticalSection
{
	CRITICAL_SECTION m_criticalSection;
public :
	CriticalSection()
	{InitializeCriticalSection(&m_criticalSection);}
	~CriticalSection()
	{DeleteCriticalSection(&m_criticalSection);}
	void enter()
	{ EnterCriticalSection(&m_criticalSection);}
	void leave()
	{ LeaveCriticalSection(&m_criticalSection);}
};
 
CriticalSection	cs;
 
int data = 0;
 
void accessSecData(int id) {
	cs.enter();
	data++;
	char str[255];
	sprintf_s( str, sizeof(str), "IdThread=%d\n", id);
	printf( str );
	Sleep(1000);
	cs.leave();
}
 
DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
	int *id = (int*)lpParameter;
	accessSecData(*id);
	return 0;
}
 
 
int _tmain(int argc, _TCHAR* argv[])
{
	CriticalSection	cs;
 
	DWORD dwThreadID;
	int t1 = 1;
	int t2 = 2;
	int t3 = 3;
	HANDLE thread1 = CreateThread( (LPSECURITY_ATTRIBUTES) NULL,
                   0,
                   (LPTHREAD_START_ROUTINE) ThreadProc,
                   (LPVOID) &t1,
                    0, &dwThreadID );
	HANDLE thread2 = CreateThread( (LPSECURITY_ATTRIBUTES) NULL,
                   0,
                   (LPTHREAD_START_ROUTINE) ThreadProc,
                   (LPVOID) &t2,
                    0, &dwThreadID );
	HANDLE thread3 = CreateThread( (LPSECURITY_ATTRIBUTES) NULL,
                   0,
                   (LPTHREAD_START_ROUTINE) ThreadProc,
                   (LPVOID) &t3,
                    0, &dwThreadID );
 
	::WaitForSingleObject( thread1, INFINITE );
	::WaitForSingleObject( thread2, INFINITE );
	::WaitForSingleObject( thread3, INFINITE );
	return 0;
}

Sortie du programme :

Code:

1
2
3
4
IdThread=1
IdThread=2
IdThread=3
Press any key to continue . . .

29/03/2006, 11h52
vincedom

:cry: NON :cry:

La CCriticalSection de MFC mappe CRITICAL_SECTION mais bon j'ai reessayer pour etre sur et CRITICAL_SECTION utilise une structure LIFO: c'est pas du PIPO :!:

Bon enfin de toute facon je vais modifier l'architecture de mon prog et vire la critical section....

Mais sans blague c pas propre du tout de pas avoir des objets pour synchroniser avec une structure FIFO... Mon prog prend quasiment continuellement 100% du cpu et il est cense faire de l'analyse en temps reel... Alors quand une thread reste bloquer 30 sec... Oups :!:
30/03/2006, 06h00
vincedom

Salut

Suite a un message prive de "themadmax" j'ai ecrit un petit prog de demo pour montrer que la structure d'attente de CRITICAL_SECTION etait pas FIFO ...
Et la 8O ca marchait parfaitement avec une belle struture FIFO....
Je suis retourne a mon prog principal pour verifier que j'etais pas fou :!: :!: :!:
Et apres une ultime recherche internet j'ai fini par trouve un truc sur msdn:
http://msdn.microsoft.com/msdnmag/issues/06/03/ConcurrentAffairs/
Au fait c du FIFO mais parfois marche pas :x !!!

Bon de toute facon de mon cote dans mon prog je vais m'arranger pour supprimer la critical section.

Merci pour votre aide :wink:

Je crois que le sujet est clos....