Änderungen von Variablen synchronisieren

[Breager]

TThreadlist hatte ich auch bereits gefunden. Allerdings fehlt dort Insert und Exchange oder habe ich etwas übersehen? Gut, das könnte man im Notfall noch selbst implementieren.

Zitat von Sir Rufo:

BTW: Du solltest immer mit einem Schutzblock arbeiten.

Ja, hast recht. Werde ich in Zukunft sofort einbauen.

EDIT: Das geht ja anscheinend doch. Muss ich mir nochmal gründlich unter die Lupe nehmen. Man lernt eben nie aus. Vielen Dank für den Hinweis.

[himitsu]

Pollen ist hier leider die einzige Möglichkeit, wenn man ein TimeOut benötigt, also bei der CS.
Ansonsten müßte man auf Events (z.B. SetEvent oder TEvent) umsteigen.

Beim Pollen muß meventuell an aufpassen, daß man nicht die CPU hochtreibt.
Ich bei da Pausen in die Schleife, so mit je um die 20 Millisekunden.
Aber dort kann man sich unter umständen auch aussperren, wenn zwei/mehrere Threads in schneller Follge drauf zugreifen und zwischen 2 Zugriffen die Zeit kürzer ist, als die Pause.

[Breager]

Zitat von himitsu:

Beim Pollen muß meventuell an aufpassen, daß man nicht die CPU hochtreibt.
Ich bei da Pausen in die Schleife, so mit je um die 20 Millisekunden.
Aber dort kann man sich unter umständen auch aussperren, wenn zwei/mehrere Threads in schneller Follge drauf zugreifen und zwischen 2 Zugriffen die Zeit kürzer ist, als die Pause.

Da reicht sogar schon eine Millisekunde aus Hatte ich die letzten Tage mal selbst getestet. Hatte das ganz falsch verstanden. Dachte, das Enter wartet genauso wenig wie das TryEnter. Habs jetzt erstmal ohne Pollen umgesetzt.

Und zwar habe ich mir eine einfache threadsichere Klasse (mit CriticalSections) gebaut, die sich um alles kümmert. Ich weiss, dafür gibts die ThreadList, die fand ich von der Schreibarbeit jedoch auch nicht wesentlich angenehmer. In meiner Klasse überlasse ich es dem Benutzer, ob er die Liste manuell sperren möchte oder ob dies automatisch geschieht.

Delphi-Quellcode:

interface
Uses Classes, SysUtils, SyncObjs;
type

  TMyList = class
    private
      MyList:TList;
      FCS : TCriticalSection;
      MustLock:Boolean; //Liste muss gesperrt werden
      Procedure Lock; //Internes Sperren
      Procedure Unlock; //Internes Freigeben

    public
      Procedure Locklist; //Manuell sperren
      Procedure Unlocklist; //Manuell freigeben

      Constructor Create;
      Destructor Destroy;
      Function Count:Integer;
      ...
   end;

implementation

Constructor TMyList.Create;
Begin
  MyList:=TList.Create;
  FCS := TCriticalSection.Create;
  MustLock:=True; //Liste muss automatisch gesperrt werden
End;

Procedure TMyList.Lock;
Begin
IF MustLock then
   FCS.Enter;
End;

procedure TMyList.Unlock;
begin
IF MustLock then
   FCS.Release;
end;


Procedure TMyList.Locklist;
Begin
 FCS.Enter;
 MustLock:=False; //Liste muss später NICHT automatisch gesperrt werden
End;

Procedure TMyList.Unlocklist; //EDIT: Reihenfolge der Codezeilen wurde getauscht
Begin
  MustLock:=True; //Liste muss später automatisch gesperrt werden
  FCS.Release;
End;

Function TMyList.Count:Integer;
Begin
 lock;
 try
  Result:=MyList.Count;
 finally
  unlock;
 end;
End;

Der Vorteil hierbei ist, dass man bei Bedarf einen größeren Code-Block sperren kann, ansonsten muss ich mich um nichts kümmern.

Mal noch ne letzte Frage, wenn man in einer Schleife mehrere Items aus der Liste löscht, ist es dann besser, die komplette Schleife zu sprerren oder nur die einzelnen Delete?

[mjustin]

Zitat von Breager:

Delphi-Quellcode:

Procedure TMyList.Unlocklist;
Begin
  FCS.Release;
  MustLock:=True; //Liste muss später automatisch gesperrt werden
End;

Die beiden Zeilen würde ich sicherheitshalber tauschen:

Delphi-Quellcode:

Procedure TMyList.Unlocklist;
Begin
  MustLock:=True; //Liste muss später automatisch gesperrt werden
  FCS.Release; // erst jetzt darf ein anderer Thread an die Liste
End;

[Breager]

Zitat von mjustin:

Die beiden Zeilen würde ich sicherheitshalber tauschen

Jo, danke. Hast recht, vertauscht ist besser (sicherer)!

[Sir Rufo]

Erklär doch mal, wofür du das MustLock in LockList und UnlockList jeweils veränderst.
Das macht in meinen Augen keinen Sinn.

[Sir Rufo]

Zitat von Breager:

Mal noch ne letzte Frage, wenn man in einer Schleife mehrere Items aus der Liste löscht, ist es dann besser, die komplette Schleife zu sprerren oder nur die einzelnen Delete?

Das kommt darauf an, wie lange das jeweils dauert und inwieweit das aus Konsistenzgründen erforderlich sein muss.

Im Allgemeinen gilt, dass die CS sobald als möglich wieder freigegeben wird.

[Breager]

Zitat von Sir Rufo:

Erklär doch mal, wofür du das MustLock in LockList und UnlockList jeweils veränderst. Das macht in meinen Augen keinen Sinn.

Wenn ich die CriticalSection über TMyList.Locklist starte, würde z.B. innerhalb von TMyList.Count ein erneuter Versuch, die CriticalSecion zu starten eine Ausführung des Codes in TMyList.Count blockieren.

Aus diesem Grund setze ich bei TMyList.Locklist MustLock:=False. Das bedeutet, dass ich z.B. innerhalb von Count keine CriticalSection mehr starten muss, da schon aktiv
IF MustLock then Lock Also wird der Code in Count ausgeführt.

[Sir Rufo]

Ja, sowas hatte ich mir gedacht

Aber das ist überflüssig und verkompliziert die Sache unnötig.

Eine CriticalSection sorgt dafür, das innerhalb selbiger nur ein ThreadKontext aktiv ist.
Innerhalb dieses ThreadKontextes kann eine CS aber beliebig oft betreten werden.
Die CS muss aber auch genauso oft wieder verlassen werden damit diese wieder frei für einen anderen ThreadKontext ist.

Delphi-Quellcode:

FCS.Enter;
FCS.Enter;
  TuWas;
FCS.Leave;
FCS.Leave;

Diese Konstrukt funktioniert problemlos, denn wenn die CS betreten werden kann, dann funktioniert auch das zweite Betreten.

[Breager]

Alles klar Danke, man lernt eben nie aus. Das Thema Threads wird mir noch die ein oder andere schlaflose Nacht bescheren (absolutes Neuland für mich)