Danke, das sieht gut aus, geskill, aber ich möchte eigentlich keine externen Komponenten benutzen.

Es sieht ungefähr so aus:

zusammenfalten · markieren

Delphi-Quellcode:

type
  T = record
    Str: string;
    Use: Boolean;
  end;

private
  A: Array[0..5] of T;

procedure TThread.Add(const S: string);
begin
  with A[GetFreeField] do
  begin
    Str := S;
    Use := True;
  end;
end;

procedure TThread.Execute;
begin
  while not Terminated do
  begin
    for I := Low(A) to High(A) do
      if Use then
      begin
        //hier werden nur Felder von A[I] gelesen und geändert
      end;
    Sleep(1);
  end;
end;

Add wird aus dem Hauptthread aufgerufen. Use ist natürlich anfangs immer False und wird vom Thread auch irgendwann wieder auf False gesetzt. Das sollte doch sicher sein?

Also wenn du Add() aufrufst bevor der Thread startet, dann geht das in Ordnung.

Nur so musst du das immer wissen, wann du es aufrufen darfst. Bei kleinen Programmen ist das noch in Ordnung, aber man sollte sich besser direkt angewöhnen das sauber umzusetzen. In dem Beispiel bei mir kann man dies ohne zu überlegen einfach aufrufen.

Das Auslesen passiert dann auch erst wieder wenn der Thread definitiv beendet wurde (z.B. via Join)?

Da es ein statisches Array ist sind die Schreibtugriffe ja wirklich nur aus die einzelnen Elemente begrenzt.

Und mit 2 Threads meinst du Hauptthread und TThread - oder?

Zitat von geskill:

Also wenn du Add() aufrufst bevor der Thread startet, dann geht das in Ordnung.

Add wird eigentlich nur aufgerufen, wenn der Thread bereits läuft. Was kann da denn passieren? Bisher lief die Anwendung eigentlich immer stabil.

Zitat von geskill:

Und mit 2 Threads meinst du Hauptthread und TThread - oder?

Jep

Kann man dein Beispiel auch mit den Windows CriticalSections (TRTLCriticalSection) umsetzen, so dass keine externe Unit/Komponente benutzt werden muss?

Die Schleife ist ja kurz und bei den heutigen leistungsstarken PC gehört schon ein bisschen Glück dazu das ein Fehler Auftritt. Weil beim Add() schreibst du ja auf einen Index I und bei jedem lesen greifst du immer auf Used von I lesend zu. Das ist nicht in Ordnung.

Mit einer TCriticalSection kannst du das nun einschränken. Der Vorteil bei den OTL Sections ist das man sie nicht initialisieren und freigeben muss. Zudem ist der MREW auch "sicherer" als der von Delphi.

OK, vielen Dank. Eine letzte Frage: Ist es denn so sicher (auch wenn es keine optimale Lösung ist)?

zusammenfalten · markieren

Delphi-Quellcode:

type
  T = record
    Str: string;
    Use: Boolean;
  end;

private
  A: Array[0..5] of T;
  CS: TRTLCriticalSection;

procedure TThread.Add(const S: string);
begin
  EnterCriticalSection(CS);
  try
    with A[GetFreeField] do
    begin
      Str := S;
      Use := True;
    end;
  finally
    LeaveCriticalSection(CS);
  end;
end;

procedure TThread.Execute;
begin
  while not Terminated do
  begin
    for I := Low(A) to High(A) do
    begin
      EnterCriticalSection(CS);
      if Use then
      begin
        LeaveCriticalSection(CS);
        //hier werden nur Felder von A[I] gelesen und geändert
      end
      else
        LeaveCriticalSection(CS);
    end;
    Sleep(1);
  end;
end;

zusammenfalten · markieren

Delphi-Quellcode:

procedure TThread.Execute;
begin
  while not Terminated do
  begin
    for I := Low(A) to High(A) do
    begin
      EnterCriticalSection(CS);
      if Use then
      begin
        //hier werden nur Felder von A[I] gelesen und geändert
      end;
      LeaveCriticalSection(CS)
    end;
    Sleep(1);
  end;
end;

zusammenfalten · markieren

Delphi-Quellcode:

procedure TThread.Execute;
begin
  while not Terminated do
  begin
    EnterCriticalSection(CS);
    try
      for I := Low(A) to High(A) do
      begin
        if Use then
          begin
            //hier werden nur Felder von A[I] gelesen und geändert
          end;
      end;
    finally
      LeaveCriticalSection(CS)
    end;
    Sleep(1);
  end;
end;

oder TThreadList verwenden.

Grüße
KLaus

So kann ich es nicht machen, da das den Thread nutzlos machen würde. Es werden in der Schleife einige Berechnungen durchgeführt. Dies würde dazu führen, dass der Hauptthread beim Einfügen einfriert.