Thread - Timer oder Thread? (Kurzanleitung)

C-O-M-M-A-N-D-E-R

Guten Morgen,
ich hab da mal so ne allgemeine Frage!
Wenn ich ein Programm hab, und das soll etwas solange tun, bis ich dem Programm sage jetzt ist gut gewesen, was ist da besser zu benutzten? nen Timer oder nen Thread (in dem eine Schleife läuft) ??

Ich würde sagen nen Thread oder?

Marc++us

Thread

Timer sind nett für einen Refresh von Dialogen o.ä., aber man kann damit keine ernsthafte Synchronisation aufbauen.

Übrigens sollten Schleifen in Threads immer zwischendurch mal die Rechenzeit wieder abgeben... sonst blubbert der Thread mit Volldampf dahin und klaut dem System sämtliche freie Rechenzeit. Zwar kommt der Rest auch weiterhin dran, aber die Systemlast wird ohne Umschaltung deutlich höher.

[ Dieser Beitrag wurde am 13.08.2002 um 08:19 Uhr von Marc++us editiert. ]

C-O-M-M-A-N-D-E-R

@Marc++us : danke hatte es mir auch schon fast gedacht!
du sagtest bei schleifen in threads rechenzeit abgeben
Wie bewerkstellige ich das?? Ich weiss wie ich nen Thread erstelle, aber davon hab ich noch nix gehört..wäre um ne erklärung dankbar

C-O-M-M-A-N-D-E-R

Anleitung (so erstelle ich einen Thread):

1. Erstelle eine Klasse abgeleitet von WinThread
2. Erstelle folgende "public´s"

virtual int Run();
CHauptDlg* m_dialogvar;
CHauptDlg* m_pOwner;
void SetOwner(CHauptDlg* pOwner) { m_pOwner = pOwner; };

3. Includiere die Hauptklasse in der Threadklasse

#include "HauptDlg.h";

4. (Hauptklasse) Nimm die Threadklasse auf

class CDeinThread;

5. Erstelle nen (?pointer) zum Thread

CDeinThread* m_xDisplayThread;

6. Nun kannst du den Thread wie folgt aufrufen

m_xDisplayThread = (CDeinThread*)
AfxBeginThread(RUNTIME_CLASS(CDeinThread), NULL,
    0, CREATE_SUSPENDED);

m_xDisplayThread->SetOwner(this);
m_xDisplayThread->ResumeThread();

So das sollte es gewesen sein..

C-O-M-M-A-N-D-E-R

Wenn Marc++us noch was zur Rechzeitfreigabe gepostet hat, werd ich diesen Thread mal in die FAQ packen

Marc++us

Aber Du setzt mich jetzt nicht unter Druck, oder?

Kurzer Exkurs:

Wenn man in einem Thread Schleifen der folgenden Form hat:

while (anything())
{
   do_something();
}

Passiert ein unschöner Effekt: der Thread gelangt nie in den "Ready-State" und das System teilt ihm daher alle noch freie Rechenzeit zu. Die Systemlast knallt hoch auf 100%.

Das kann notwendig sein, wenn der Thread wirklich mit Hochdruck etwas erledigen muß.

Oftmals ist dies aber auch eine Fehlkonstruktion, weil die Schleife auf etwas warten oder die Abfrage gar nicht so oft ausführen muß. In solchen Fällen wirkt z.B. ein WaitForSingleObject

while (anything())
{
   do_something();
   // warte nun auf ein Synchronisationsobjekt
   WaitForSingleObject(...);
}

oder ein Sleep

while (anything())
{
   do_something();
   // setzt Thread auf Ready
   Sleep(0);
}

Wunder. Einfach mal ausprobieren und die Rechenlast vergleichen. Die Lösung mit WaitForSingleObject ist etwas komplizierter, da man sich hier schon überlegen muß worauf man wartet - aber selbst wenn man einfach eine for-Schleife über 100000 Datensätze drüberrutschen läßt in dem Thread, ist so ein kleines Sleep an der richtigen Stelle eine Wohltat für die Systemlast.

Ich empfehle an dieser Stelle einige Experimente, um einen Eindruck vom Unterschied zu bekommen.

RenéG

Apropos Rechenzeit abgeben:

Während man in in einer Schleife auf die Beendigung eines Threads wartet, der mit recht geringer Priorität laufen soll, kann man das Abfragen des Beendigungs-Events mit einem TimeOut versehen, etwa folgendermassen:

while( WaitForSingleObject( hEventThreadBeenden, 10) == WAIT_TIMEOUT)
{
  // do something
}

Wenn die Priorität des Threads manuell mit SetPriority auf unter 'Normal' gestellt wurde, wüßte ich allerdings nicht, wozu man in Zählschleifen oder so noch Rechenzeit abgeben sollte. Dies macht das System auf Basis seiner Zeitscheibenautomatik von selber.
Außerdem hat ein Thread innerhalb eines Prozesses immer eine geringere Priorität als der Prozess.

C-O-M-M-A-N-D-E-R

Alles Klar...
ne ich setzt dich jetzt nicht unter Druck..