Zitat von Olli:

@BlackJack: a.) geht auch das nicht ohne Synchronisation,

aber wenn man in dem Timer-Event jetzt z.b. nur einen Integer aus der Thread-Instanz auslesen will, muss man doch nicht synchronisieren, oder? ich dachte immer man müsste nur synchronizieren, wenn man auf grafische Koponenten zugreift.

Zitat von Olli:

b.) bitte keine Timer. Wenn er schon Threads benutzt, dann auch konsequent. Da wären Timer nur Ressourcenverschwendung.

naja ich finde es irgendwie unnütz, nur für z.b. eine regelmäßige ausgabe eines Wertes extra eine eigene Thread-klasse zu schreiben und die dann die ganze zeit warten zu lassen, da meiner meinung nach dafür ein Timer voll und ganz ausreicht. und wenn man das Timerintervall auf 1 sekunde oder so setzt, dann dürfte der ja auch nicht allzu viele resourcen fressen (ich weiss jetzt natürlich nicht ob das für das gegebene problem ein geeigneter wert wäre).

Zitat von BlackJack:

aber wenn man in dem Timer-Event jetzt z.b. nur einen Integer aus der Thread-Instanz auslesen will, muss man doch nicht synchronisieren, oder? ich dachte immer man müsste nur synchronizieren, wenn man auf grafische Koponenten zugreift.

Du mußt immer dann synchronisieren, wenn es 2 verschiedene aber potentiell gleichzeitig laufende Instanzen gibt, die ein Datum lesen oder schreiben.

Nur bei DWORD, Word und Byte (und auf Win64 auch ULONGLONG) kannst du atomares Lesen und Schreiben ohne viel Brimborium garantieren. Natürlich würde man, wenn Lesen und Schreiben getrennt stattfinden, auch getrennte Critical Sections benutzen.

Das mit den grafischen Komponenten verwechselst du schonmal mit der VCL und TThread. Dies ist nicht voll allgemeingültig.

Meine Threads sehen i.a. immer so aus ('Workerthreads'):

markieren

Delphi-Quellcode:

Procedure TMyThread.Execute;
Begin
  While Not Terminated do
    If WaitForSingleObject (hndSempahore, dwMyTimeout) = WAIT_OBJECT_0 Then
      // führe den Auftrag aus
    else
      // Timeout Verarbeitung
End;

Das 'hndSemaphore' ist ein mit 'CreateSemaphore' erzeugtes Handle auf eine Semaphore. Das ist sowas wie ein Zähler.
WaitForSingleObject wartet solange, bis die Semamphore (der Zähler) > 0 ist. Mit 'ReleaseSemaphore' 'addiert' man etwas zur Semaphore und kann so dem Thread sagen, das er loslegen soll. Das Ganze ist absolut Threadsicher.

Ich würde einen Thread schreiben, der im Hintergrund Daten einliest und in einen Buffer schreibt (z.B. einem FIFO oder Queue). Nach dem Schreiben eines Datenpaketes, oder wenn der Buffer halbvoll ist oder so, wird ein zweiter Thread angestossen, der die Daten aus dem Buffer ausliest und weiterverarbeitet (z.B. zeichnet). Dieser zweite Thread wird natürlich auch über eine Semaphore angestossen.

Wenn ich die Weiterverarbeitung nur mit einem Zeitgeber (threadgesteuert oder als Timer) mache, kann es passieren, das der Buffer zu voll wird.

Der Vorteil dieser Methode ggü einem einfachen Suspend/Resume ist die mögliche Behandung eines Timeouts. Ich finde es auch nicht ästhetisch, wenn ein Thread sich per Suspend selbst schlafen legt. Aber das ist Geschmackssache.