kritischer Bereich

hand

Hallo,
kennt jemand ein gutes Tutorial oder ähnliches über die Threads und der Zugriff auf Daten.

Ich habe ständig das Problem, dass ich in einem Thread die Daten in der Oberfläche visualisieren möchte. In einem anderen Thread werden die Daten verändert.
Mit der Methode

WaitForSingleObject(VisDataSynchro, 0) == WAIT_OBJECT_0

ist es irgendwie nicht komfortabel.

Wie kann man kritische Bereiche in MFC benutzen??

Unix-Tom

FAQ!!!!

hand

Danke, aber ich habe da nichts passendes gefunden.

Ich bin schon ein Stückchen weiter, aber irgendwie läuft es noch nicht so richtig.
Also 2 Threads und eine gemeinsame Klasse:
Jetzt nehme ich CMutex zur Synchronisierung:
Thread1:

//__________Thread1.H__________

extern CMutex M_Vis;

//_______im Thread1.cpp_____
...
while(1)
{
 //Daten sperren
  if(M_Vis.Lock())
  {
    myClass->getVar();
  }
  M_Vis.Unlock();
  sleep(100);
}
...

Der Thread2 wird nur ca. alle 500ms erstellt:

//__________Thread2.H__________
CMutex M_Vis;

//__________Thread2.cpp________
...
 //Daten sperren
  if(M_Vis.Lock(10))
  {
   myClass.setVar();
  }
  M_Vis.Unlock();
...

Irgendwie wird die Variable nicht abgeholt. Kann mir da jemand weiterhelfen?

jencas

Warum machst Du den CMutex nicht zu Membervariablen von myClass und implementierst das Locking in getVar() und setVar()?

hand

Das verschiebt das Problem nur. Aber ein guter Vorschlag, den ich gleich umgesetzt habe. Vielen Dank.

Es funzt aber trotzdem nicht. Nur wenn ich den Thread immer wieder neu starte(Dialog schliessen und öffnen) können die geschützten Variablen gelesen werden.

Ich habe einfach keine Idee mehr woran es liegen sollte.

hustbaer

Zeich mal mehr von der Cooooode

BorisDieKlinge

hast du den Mutex irgendwo global deklaiert? hast du den Mutex jeweil als referenz in deinen thread klassen? Kannst ja mal meine gebastelten Mutexe und lock klasse verwenden

class Mutex{
    CRITICAL_SECTION _critSection;
public:

    Mutex () { InitializeCriticalSection (& _critSection); }
    ~Mutex () { DeleteCriticalSection (& _critSection); }
    void Acquire(){ EnterCriticalSection (& _critSection); }
    void Release(){ LeaveCriticalSection (& _critSection); }
}; 	

class Lock {

private:
    Mutex & _mutex;
public:
    // Acquire the state of the semaphore
    Lock (Mutex &mutex): _mutex(mutex){  _mutex.Acquire();   }
    // Release the state of the semaphore
    ~Lock (){ _mutex.Release(); }
};

Martin Richter

@BorisDieKlinge:
Wir sind hier im MFC Forum. Warum verwendest Du eigentlich nicht die MFC-MT Klasesen. CSingleLock, CCriticalSection etc...?

BorisDieKlinge

@Martin: Die klassen hatte ich schon bevor ich MFC hatte^^ ich wollte ihm damit nich sagen er soll diese verwenden, er soll damit sehen wie die ding funktionieren:)

simon.gysi

Eine andere Möglicheit für das Problem des OP wäre noch Messages zu benutzen.
Simon

hand

Hallo,
ich habe jetzt mal versucht in einem kleinen Projekt alles nachzubauen:
Meine Klasse, auf welche gemeinsam zugegriffen wird:

//Header
class CMyClass
{
private:
  int data;
  CMutex MuVis;
public:
  void setData(int i);
  int  getData(void);
protected:
};
//cpp
//hier wohl der Fehler liegen
void CMyClass::setData(int i)
{
  MuVis.Lock();
  data = i;
  MuVis.Unlock();
}
int  CMyClass::getData(void)
{
  MuVis.Lock();
  return this->data;
  MuVis.Unlock();
  return -1;
}

Die Threads:

//*************************Thread1*************************
UINT Thread1(LPVOID hWnd)
{
  CMyClass *pMyClass = (CMyClass*)hWnd;
  int i=0;
  while(1)
  {
    if(WaitForSingleObject(Thread1,0) == WAIT_OBJECT_0)
    {
      AfxEndThread(1);
    }
    pMyClass->setData (i);
    ++i;
    if(i>10000)
      i=0;
  }
  AfxEndThread(1);
  return 1;
}
//*************************Thread2*************************
UINT Thread2(LPVOID hWnd)
{
  CMyClass *pMyClass = (CMyClass*)hWnd;
  int i;
  while(1)
  {

    if(WaitForSingleObject(Thread2,0) == WAIT_OBJECT_0)
    {
      AfxEndThread(2);
    }
    i = pMyClass->getData();
  }
  AfxEndThread(2);
  return 2;
}

simon.gysi

Hi,
Ohne alles andere gelesen zu haben ist mir folgedens aufgefallen:

int  CMyClass::getData(void)
{
  MuVis.Lock();
  return this->data;
  MuVis.Unlock();
  return -1;
}

1. return -1 ist komplett überflüssig.
2. MuVis.Unlock() wird nie aufgerufen, da return this->data; vorher aus der Funktion springt.

-> Für Punkt 2. eine Lösung nehmen, die den Scope berücksichtigt.
Simon

hand

mmh, ja ich glaube, dass das jetzt letztendlich nur der Fehler war. Mit return aus der Funktion raus ohne den Mutex freizugeben.

Vielen Dank an eure Geduld und eure schnellen Antworten!