zwei threads mit CCriticalSection + vector<> hängen sich auf

[Gehirnmann]

hi,

also ich hab zwei threads, beide greifen auf einen vector im document einer SDI anwendung zu,
1. thread = MFC fenster, wenn neuzeichnen
2. thread = WIN-API thread, wenn neue daten

ich hab im doc ne critical section um die lesende funktion des 1. thread gemacht, die gleiche critical section nutzt der 2. thread zum schreiben (anhängen von daten) im vector

//globally declared
CRITICAL_SECTION	g_CritSect;

//in 1. function to read from vector
EnterCriticalSection(&g_CritSect);
 currData = m_vData[elem];
LeaveCriticalSection(&g_CritSect);

//in 2. function to write to it
EnterCriticalSection(&g_CritSect);
 m_vData.push_back(newData);
LeaveCriticalSection(&g_CritSect);

wenn der thread die 2. function aufruft, dann gibts nen dead-lock.
was kann das sein? benutze ich die critical section falsch?
eigentlich sollte doch der 2. thread erst zugriff bekommen wenn der erste die critical section verlassen hat oder?

danke fuer jeden tipp
gm

[EarlyBird]

Hallo,

hast du die CriticalSection auch initialisiert?

Um vor späteren Problemen vorzubeugen, würde ich die Section in eine Klasse
packen.

class CriticalSection
{
public:
	CriticalSection()
	{
		::InitializeCriticalSection(&m_cs);
	}

	~CriticalSection()
	{
		::DeleteCriticalSection(&m_cs);
	}

	void Lock()
	{
		::EnterCriticalSection(&m_cs);
	}

	void UnLock()
	{
		::LeaveCriticalSection(&m_cs);
	}

	class Owner
	{
	public:
		Owner(CriticalSection& cs)
			: owner(cs)
		{
			owner.Lock();
		}

		~Owner()
		{
			owner.UnLock();
		}

	private:
		CriticalSection& owner;
	};

private:
	CRITICAL_SECTION	m_cs;
};

// irgendwo in deinem Quelltext legst du nun eine Instanz der Klasse 
// CriticalSection an und verwendest den Zugriff über die
// CriticalSection::Owner Klasse.

CriticalSection g_cs // globales Objekt

void Read()
{
   CriticalSection::Owner Lock(g_cs); // Section wird gelockt

   // syncronisierter Abschnitt

} // function geht out of scope (Lock wird zerstört und gibt Lock auf Sektion wieder frei!