Allgemeine Fragen zu Thread-Safety

[s.h.a.r.k]

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?
   
   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:
   
   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.
   
   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?
   
   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