Hallo zusammen,

ich habe im Moment immer wieder das Problem, dass ich nicht so recht weiß, ob hier oder da was absichern muss oder nicht. Hier mal ein paar Beispiele, bei denen mir das irgendwie nicht so recht klar ist. Bitte immer mit Begründung antworten und nicht rein aus dem Bauch heraus

Eines noch vorab: Lock() = FCriticalSection.Enter(), Unlock() = FCriticalSeciton.Leave().

1. Konstruktoren: Welche der beiden Methoden sollte genutzt werden?
   
   zusammenfalten · markieren

   Delphi-Quellcode:

   constructor TMyObject.CreateA();
   begin
     Lock();
     try
       inherited Create();
       FMemberA := 1;
       FMemberB := 'Delphi';
       Blub();
       Bla();
     finally
       Unlock();
     end;
   end;
   
   // oder
   
   constructor TMyObject.CreateB();
   begin
     inherited Create();
     FMemberA := 1;
     FMemberB := 'Delphi';
     Blub();
     Bla();
   end;
2. Destruktoren: Zunächst ist mir klar, dass diese abgesichert werden sollten, da mehrere Threads ja auch die gleichen Ressourcen zugreifen können. Allerdings erscheint doch imho eine Exception, wenn ein Thread das Objekt freigibt und ein zweiter lesen will. Folgendes Beispiel: Thread A ruft Destroy auf und Thread B den Getter für Stupid. Thread A erhält den Vorang und Thread B muss somit beim Lock des Getter warten. Lustig wirds da dann, wenn Thread A Unlock() verlassen hat und dann die CriticalSection freigibt, während Thread B dann ja eigentlich lesen darf und die CriticalSection benötigt. Hier mal der Code dazu:
   
   zusammenfalten · markieren

   Delphi-Quellcode:

   function GetStupid(): string;
   begin
     Lock();
       Result := FStupid;
     finally
       Unlock();
     end;
   end;
   
   destructor TMyObject.Destroy();
   begin
     Lock();
     try
       FreeAllThings();
       CleanTheKitchen();
       inherited Destroy();
     finally
       Unlock();
       FCriticalSection.Free();
     end;
   end;
   Insgesamt würde ich sagen, dass sobald so eine Situation auftritt, es sich um ein Designfehler handelt und dieses Konzept überdacht werden sollte. Daraus schließe ich aber, dass man einen Destruktor ja gar nicht absichern muss, da es ja eigentlich immer krachen wird.
   
   
3. Einfacher verschachtelter Aufruf: Passt das so, oder muss ich die zweite A-Methode auch noch mit Lock()/Unlock() absichern? Hier wird ja nur eine Variable einfachen Typs übergeben.
   
   zusammenfalten · markieren

   Delphi-Quellcode:

   procedure TMyObject.A(Param: Integer);
   begin
     Lock();
     try
       DoSomething(Param);
     finally
       Unlock();
     end;
   end;
   
   procedure TMyObject.A();
   var
     i : Integer;
   begin
     i := 10;
     A(i);
   end;
4. Komplexerer verschachtelter Aufruf:
   (a) Eigentlich die gleiche Frage, wie unter 3., allerdings hier noch eine Stufe mehr verschachtelt und mit einem Objekt und Record anstatt eines einfachen Typs.
   (b) Angenommen DoSomething() würde das Param-Objekt in einen threadsicheren Puffer pushen und nichts anderes anstellen, bräuchte ich dann das Lock() und Unlock() doch nicht, oder?
   
   zusammenfalten · markieren

   Delphi-Quellcode:

   procedure TMyObject.A(Param: TObject; FS : TFormatSettings);
   begin
     Lock();
     try
       DoSomething(Param, FS);
     finally
       Unlock();
     end;
   end;
   
   procedure TMyObject.A(Param: TObject);
   var
     FS : TFormatSettings
   begin
     FS := SysUtils.FormatSettings;
     A(Param, FS);
   end;
   
   procedure TMyObject.A();
   var
     Obj: TObject;
   begin
     Obj := TObject.Create()
     A(Obj);
   end;

Ich glaub, das wars fürs erste

Zu Punkt 1 und 2:
Erzeugen und und freigeben sollte immer nur einer. Alles andere ist imho, wie du schon festgestellt hast, ein Designfehler.
Beim Konstruktor ist es noch einfacher: solange der sich noch nicht zurückgemeldet hat, weiß ja niemand von dem neuen Objekt. Also kann es innerhalb des Objektes keine Kollision geben.

3.: Passt so.

5. Nicht (unbedingt) threadsichere Methoden: Ich habe gerade einen Konstruktor geschrieben, der die Format-Methode nutzt. Ich weiß ja pauschal nicht, ob diese Methode threadsafe ist oder nicht. Daher hätte ich dann diesen Code ...

markieren

Delphi-Quellcode:

constructor TMyObject.Create(const AFormat: string; const Args: array of const);
begin
  inherited Create();
  FMessage := Format(AFormat, Args);
end;

... wie folgt umgeschrieben. Dieses Problem ist ja auch auf jede andere beliebige Methode "anwendbar" und nich auf Konstruktoren beschärnkt.

zusammenfalten · markieren

Delphi-Quellcode:

constructor TMyObject.Create(const AFormat: string; const Args: array of const);
begin
  inherited Create(); // Erzeugt eine CriticalSection, da von
                      // entsprechender Basisklasse abgeleitet
  Lock();
  try
    FMessage := Format(AFormat, Args);
  finally
    Unlock();
  end;
end;

5.: Das dürfte wirkungslos sein, da die CriticalSection scheinbar pro Objekt existiert. So würde zwar jeder Thread das Lock setzen, aber kein anderer würde sich daran stören.

PS: Mir scheint das Problem besteht bei allen anderen Beispielen auch.
PPS: Bei einem zeitkritischen Projekt habe ich mal festgestellt, das TCriticalSection entschieden langsamer war, als RTL_CRITICAL_SECTION. Warum konnte ich leider nicht ergründen

Zitat von s.h.a.r.k:

Ich habe gerade einen Konstruktor geschrieben, der die Format-Methode nutzt. Ich weiß ja pauschal nicht, ob diese Methode threadsafe ist oder nicht.

1. hat das gar nichts mit dem Konstruktor zu tun, sondern gilt für jeden Aufruf von Format aus verschiedenen Threads.

2. nimmt man deswegen immer die threadsichere Variante von Format, bei der man die FormatSettings mit angibt. Es ist nämlich nicht der Code von Format, der nicht threadsicher ist, sondern die Verwendung der globalen FormatSettings.

Zitat von Uwe Raabe:

Zitat von s.h.a.r.k:

Ich habe gerade einen Konstruktor geschrieben, der die Format-Methode nutzt. Ich weiß ja pauschal nicht, ob diese Methode threadsafe ist oder nicht.

1. hat das gar nichts mit dem Konstruktor zu tun, sondern gilt für jeden Aufruf von Format aus verschiedenen Threads.

2. nimmt man deswegen immer die threadsichere Variante von Format, bei der man die FormatSettings mit angibt. Es ist nämlich nicht der Code von Format, der nicht threadsicher ist, sondern die Verwendung der globalen FormatSettings.

Ich habe diese Format-Methode leider nicht bis ins letzte Details ergründet, da dort auch irgendwann mal mit Assembler hantiert wird. Aber danke für den Hinweis. Habe gerade auch den Quellcode-Kommentar von TFormatSettings gelesen. Irgendwie muss man bei Threads viel zu viel beachten

Zitat von chaosben:

5.: Das dürfte wirkungslos sein, da die CriticalSection scheinbar pro Objekt existiert. So würde zwar jeder Thread das Lock setzen, aber kein anderer würde sich daran stören.

PS: Mir scheint das Problem besteht bei allen anderen Beispielen auch.

Stimmt... D.h. ich muss mir somit für dies Format-Methode einen threadsicheren Wrapper basteln, oder wie Uwe Raabe vorgeschlagen hat, die Format-Methode immer mit dem FormatSettings-Parameter aufrufen.

Zitat von chaosben:

PPS: Bei einem zeitkritischen Projekt habe ich mal festgestellt, das TCriticalSection entschieden langsamer war, als RTL_CRITICAL_SECTION. Warum konnte ich leider nicht ergründen

Dank für die Info. Interessant wäre jetzt noch zu wissen, wie hoch der Geschwindigkeitsgewinn denn gewesen ist?

Tschaa ... jetzt wolle ich ne kleine Demoapp schreiben (bezüglich der Zeit) und da taucht das Problem nicht mehr auf.
Mal sehen, vielleicht finde ich die alten Sourcen noch mal.

Zitat von chaosben:

5.: Das dürfte wirkungslos sein, da die CriticalSection scheinbar pro Objekt existiert. So würde zwar jeder Thread das Lock setzen, aber kein anderer würde sich daran stören.

Die könnte man als class var speichern und dafür im class contructor initialisieren und im class destructor wieder freigeben.

Zitat von chaosben:

Tschaa ... jetzt wolle ich ne kleine Demoapp schreiben (bezüglich der Zeit) und da taucht das Problem nicht mehr auf.
Mal sehen, vielleicht finde ich die alten Sourcen noch mal.

TCriticalSection ist eigentlich nur ein Wrapper für eine RTL_CRITICAL_SECTION, ergo wird das wohl gleich schnell sein. Muss daher wohl am Projekt selbst gelegen haben.

Zitat von jaenicke:

Zitat von chaosben:

5.: Das dürfte wirkungslos sein, da die CriticalSection scheinbar pro Objekt existiert. So würde zwar jeder Thread das Lock setzen, aber kein anderer würde sich daran stören.

Die könnte man als class var speichern und dafür im class contructor initialisieren und im class destructor wieder freigeben.

Jup, das ist klar. Aber bevor ich da jeder Klasse eine extra CriticalSection mitgebe, schreibe ich mir da dann doch liebe einmal eine threadsichere Methode, die das Format eben entsprechend kapselt