Hi, ist es sicher, wenn ein Thread lesend und schreibend auf ein Index eines Array zugreift und ein anderer Thread lesend und schreibend auf das gleiche Array mit einem anderen Index zugreift? Oder müssen alle Zugriffe synchronisiert werden?

Sollte theoretisch sicher sein, solange wirklich immer nur ein Thread auf einen Index gleichzeitig zugreift.

OK, danke für die Antwort.

Und sich das Array selber nicht verändert, also kein SetLength und Co.

Was ist das denn für ein Array?

Hallo luke2,
du kannst dafür am besten einen MREW benutzen. Damit können mehrere Threads gleichzeitig lesend drauf zugreifen, aber immer nur einer schreibend. Natürlich müssen beide Threads die gleiche Instanz von dem TSafeArray bekommen

Bei so kritischen Sachen würde ich nie wie du vorhast die Array Instanz einem Thread direkt mitteilen.

Dies ist eine vereinfachtere Variante die ich gerade im Einsatz habe:
Das ist an sich eigentlich schon ziemlich performant, aber du könntest jetzt ein lokales Array/Liste etc. anlegen, die alle Lesezugriffe auf die versch. Indexe speichert. Und beim Schreiben wird dann geprüft ob dieser Index in der Liste ist, wenn ja muss dort beim zugreifen eben gewartet werden. Aber ich würde das mit dem gleichzeitigen auf ein Index auch sein lassen und immer als schreibend behandeln.

zusammenfalten · markieren

Delphi-Quellcode:

uses
  // Delphi
  Math,
  // OmniThreadLibrary
  OtlSync;

type
  TSafeArray = class
  private
    FArray: array of Integer;
    FLock: TOmniMREW;
  public
    constructor Create;

    procedure SetResult(AIndex: Integer; const AValue: Integer);
    function GetResult(AIndex: Integer): Integer;
  end;

constructor TSafeArray.Create;
begin
  SetLength(FArray, 0);
end;

procedure TSafeArray.SetResult(AIndex: Integer; const AValue: Integer);
begin
  FLock.EnterWriteLock;
  try
    SetLength(FArray, Max(AIndex, length(FArray)) + 1); // Lesezugriff: length(); Schreibzugriff!: SetLength()
    FArray[AIndex] := AValue; // Schreibzugriff: FArray[Index]
  finally
    FLock.ExitWriteLock;
  end;
end;

function TSafeArray.GetResult(AIndex: Integer): Integer;
var
  Index: Integer;
begin
  Result := -1;

  Index := AIndex;

  FLock.EnterReadLock; // starte das lesen
  try
    if Index < length(FArray) then // Lesezugriff: length()
      Result := FArray[Index]; // Lesezugriff: FArray[Index]
  finally
    FLock.ExitReadLock; // beende das lesen
  end;
end;

Grüße

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?