Ringpuffer Bibliothek veröffentlicht

[Uwe Raabe]

Jetzt alle relevanten Methoden in Enter/Leave zu klammern halte ich für wenig hilfreich, denn das sind in non-threadsafe Fall immer zwei überflüssige Calls. Davon abgesehen wird das in einigen Fällen auch nicht reichen, z.B. wenn man erwartet, dass ein Peek gefolgt von einem Pop ein konsistentes Ergebnis liefert. Aber auch das property Notify ist mit dem direkten Feldzugriff nicht wirklich threadsicher.

TRingBuffer in einer thread-safe Version ableiten läuft konträr zur aktuellen Ableitungsphilosophie mit TObjectRingbuffer . Man müsste dann womöglich jede Ableitung in zwei Flavors machen:

TRingbuffer<T> -> TThreadsafeRingBuffer<T>
TObjectRingbuffer<T:class> -> TThreadsafeObjectRingbuffer<T:class>

Das erscheint mir nicht sonderlich sinnvoll.

Ein möglicher Ansatz, der den ursprünglichen Ringbuffer unangetastet lässt, wäre ein Wrapper für den Zugriff - analog zu TThreadList :

Delphi-Quellcode:

type
  TThreadRingBufferWrapper<T> = class
  private
    FLock: TObject;
    FRingBuffer: TRingBuffer<T>;
  public
    constructor Create(ARingBuffer: TRingBuffer<T>);
    destructor Destroy; override;
    function LockBuffer: TRingBuffer<T>;
    procedure UnlockBuffer; inline;
  end;

...

constructor TThreadRingBufferWrapper<T>.Create(ARingBuffer: TRingBuffer<T>);
begin
  inherited Create;
  FRingBuffer := ARingBuffer;
  FLock := TObject.Create();
end;

destructor TThreadRingBufferWrapper<T>.Destroy;
begin
  LockBuffer;
  try
    FRingBuffer.Free;
    inherited Destroy;
  finally
    UnlockBuffer;
    FLock.Free;
  end;
end;

function TThreadRingBufferWrapper<T>.LockBuffer: TRingBuffer<T>;
begin
  TMonitor.Enter(FLock);
  Result := FRingBuffer;
end;

procedure TThreadRingBufferWrapper<T>.UnlockBuffer;
begin
  TMonitor.Exit(FLock);
end;

[TurboMagic]

Hallo,

die Idee ist glaube ich gar nicht so schlecht!
Wenn die anderen diese auch als sinnvoll ansehen muss die nur noch jemand
offiziell einspeisen...

Am besten mit den Unit Tests die man, trotz der Schwierigkeiten Multithreaded
Code Unit getestet zu bekommen, umsetzen kann gleich beigesteuert. Am besten in
einer neuen Unit Test Klasse/Fixture...

Grüße
TurboMagic

[Uwe Raabe]

Ich habe das nochmal etwas verallgemeinert, da der Wrapper ja gar nichts über die zu wrappende Instanz wissen muss. Damit kann das als Wrapper für quasi jede Objekt-Instanz herhalten und man bekommt über LockInstance auch gleich den tatsachlich übergebenen Typ zurück mit allen dort verfügbaren Methoden und Eigenschaften.

Delphi-Quellcode:

type
  TThreadWrapper<T: class> = class
  private
    FLock: TObject;
    FInstance: T;
    FOwnsInstance: Boolean;
  public
    constructor Create(AInstance: T; AOwnsInstance: Boolean = True);
    destructor Destroy; override;
    function LockInstance: T;
    procedure UnlockInstance; inline;
    property OwnsInstance: Boolean read FOwnsInstance write FOwnsInstance;
  end;

...

constructor TThreadWrapper<T>.Create(AInstance: T; AOwnsInstance: Boolean = True);
begin
  inherited Create;
  FInstance := AInstance;
  FLock := TObject.Create();
  FOwnsInstance := AOwnsInstance;
end;

destructor TThreadWrapper<T>.Destroy;
begin
  LockInstance;
  try
    if OwnsInstance then
      FInstance.Free;
    FInstance := nil;
    inherited Destroy;
  finally
    UnlockInstance;
    FLock.Free;
  end;
end;

function TThreadWrapper<T>.LockInstance: T;
begin
  TMonitor.Enter(FLock);
  Result := FInstance;
end;

procedure TThreadWrapper<T>.UnlockInstance;
begin
  TMonitor.Exit(FLock);
end;

[himitsu]

Jupp, einige Methoden/Property kann man nicht Thread-safe machen.

Außer man lässt solch problematischen Methoden weg. Und falls man sie dennoch benötigt, dann in einer SubKlasse (ala LockBuffer) verstecken,
oder in diesen Methoden/Property eine Exception werfen, wenn vorher extern kein Enter/Lock gestartet wurde.

Die komplette Klasse muß man da nicht wegsperren, um die einachen Sachen weiterhin einfach/direkt aufrufen zu können.



Wenn FInstance immer keine Klasse ist, dann kannst statt FLock auch direkt FInstance verwenden, oder den TThreadWrapper selbst.