Hallo zusammen,

ich habe die Suchfunktion nun schon länger geplagt und schon einige Beispiele durch. Leider hat es mir noch immer nicht auf die Sprünge geholfen.

Bei ist ein Thread zuständig Daten zu sammel, der Andere soll Diese per TCP/IP bereitstellen.
Beide Threads arbeiten wie erwartet, aber sobald ich die gesammelten Daten (4 double) in die property des anderen thread schreiben möchte bekomm ich eine Fehlermeldung:

Zugriffsverletzung ... Schreiben von Adresse ...

zusammenfalten · markieren

Delphi-Quellcode:

      Synchronize(ExtUpdate);

// ...

procedure ThreadValue.ExtUpdate;
begin
  TCPIP.TCP_NO2_10 := NO2_10;
  TCPIP.TCP_NO2_06 := NO2_06;
  TCPIP.TCP_CompAir := CompAir;
  TCPIP.TCP_Coolant := Coolant;
end;

Bisher bin ich davon ausgegangen, dass ich mit einem Synchronize() es schaffe auf den anderen Thread zu zu greifen.


Ich bin über eure Hilfe dankbar,
leider noch Anfänger, was Delphi betrifft und OOP, daher evtl. auch auf dem Holzweg

Schau Dir mal TMultiReadExclusiveWriteSynchronizer an

Zitat von CCRDude:

Schau Dir mal TMultiReadExclusiveWriteSynchronizer an

Als Alternative gibts dann nach die TCriticalSection aus der Unit SyncObjs

Zitat von chaosben:

Zitat von CCRDude:

Schau Dir mal TMultiReadExclusiveWriteSynchronizer an

Als Alternative gibts dann nach die TCriticalSection aus der Unit SyncObjs

Und dann ist da noch System.TMonitor (für das eigens TObject erweitert wurde).

Zitat von chaosben:

Zitat von CCRDude:

Schau Dir mal TMultiReadExclusiveWriteSynchronizer an

Als Alternative gibts dann nach die TCriticalSection aus der Unit SyncObjs

Eine TCriticalSection sperrt aber immer komplett beim Lesen und Schreiben (Enter..Leave), der TMultiReadExclusiveWriteSynchronizer sperrt aber immer nur bei Schreibzugriffen (BeginWrite..EndWrite).
Somit sind die schon mal A sehr verwandt und B in einer MultiThread-Umgebung besser.

Allerdings in dieser vom TE aufgezeigten Konstellation nicht notwendig (2 Threads schreibend, 1 Thread lesend)
Der Aufwand die beiden zu implementieren bleibt aber gleich, somit würde ich dem TMultiReadExclusiveWriteSynchronizer wohl doch den Vorzug geben

Zitat von Sir Rufo:

Eine TCriticalSection sperrt aber immer komplett beim Lesen und Schreiben (Enter..Leave), der TMultiReadExclusiveWriteSynchronizer sperrt aber immer nur bei Schreibzugriffen (BeginWrite..EndWrite).
Somit sind die schon mal A sehr verwandt und B in einer MultiThread-Umgebung besser.

Wenn sich aber beim Lesen etwas verändert, dann zählt das als Schreibzugriff und muß ebenfalls gesperrt werden.
z.B. das Auslesen eines Streams, wo sich ja der Positionszeiger ändert.

[QUOTE=Sir Rufo;1126379]

Zitat von chaosben:

Der Aufwand die beiden zu implementieren bleibt aber gleich, somit würde ich dem TMultiReadExclusiveWriteSynchronizer wohl doch den Vorzug geben

Seit ich weiß, wie langsam der TMREWS ist, mag ich ihn nicht mehr.
Oder anders gesagt: Wenn man keine rekursiven Aufrufe oder Elevation braucht, ist SlimReadWriteLock die viel schnellere Variante.

Hallo,

vielen Dank für eure Antworten, durch eine Erkältung komm ich erst jetzt wieder zur Sache.

Habe mich nun was die kritischen Bereiche betrifft versucht kundig zu machen.
Mit einem kritischen Bereich schütze ich Speicherbereiche.
Wenn ich nun eine Property damit schützen möchte, so muss ich die Methode für den kritischen Bereich in die Lese- und in die Schreibmethode der Property packen?

markieren

Delphi-Quellcode:

function ThreadValue.getNO2_10: Double;
begin
  try
    CSNO2_10.Acquire; // lock out other threads
    Result := FNO2_10;
  finally
    CSNO2_10.Release;
  end;
end;

markieren

Delphi-Quellcode:

procedure ThreadValue.setNO2_10(const Value: Double);
begin
  try
    CSNO2_10.Acquire; // lock out other threads
    FNO2_10 := Value;
  finally
    CSNO2_10.Release;
  end;
end;

So habe ich die Kritischen Bereiche definiert:

markieren

Delphi-Quellcode:

type
  ThreadValue = class(TThread)

  private
    { Private-Deklarationen }

    CSNO2_10: TCriticalSection;
    CSNO2_06: TCriticalSection;
    CSCompAir: TCriticalSection;
    CSCoolant: TCriticalSection;

markieren

Delphi-Quellcode:

{ ThreadGetValue }

procedure ThreadValue.Execute;
begin
  CSNO2_10 := TCriticalSection.Create;
  CSNO2_06 := TCriticalSection.Create;
  CSCompAir := TCriticalSection.Create;
  CSCoolant := TCriticalSection.Create;

Wenn ich nun mit meinem anderen Thread

markieren

Delphi-Quellcode:

type
  ThreadTCP = class(TThread)
  private
    { Private-Deklarationen }
    media: ThreadValue;

Versuche eine der Propertys aus zu lesen:
Self.FNO2_10 := media.NO2_10; so sehe ich, beim debuggen, dass die Methode
CSNO2_10.Acquire; // lock out other threads Immer einen Fehler verursacht und dadurch nie ein Wert gelesen werden kann.

Ich bin davon ausgegangen, dass mir eine lokale CriticalSection genügt, wenn diese in der "set" und "get" Methode eingebunden ist.

Vielen Dank für die weitere Hilfe runter vom Holzweg

Zitat von fuchsle:

Bisher bin ich davon ausgegangen, dass ich mit einem Synchronize() es schaffe auf den anderen Thread zu zu greifen.

Synchronize() bringt dich in den Kontext des Hauptthreads, dein anderer Thread ist davon nicht betroffen.

Es gibt von Synchronize aber auch noch ein paar überladene Methoden, wo man den gewünschten Thread-Kontext angeben kann.

Ansonsten mit Critical Sections arbeiten, wenn die Daten einfach nur abgeliefert werden sollen.

Und anstatt Synchronize kann man es auch mal mit Queue versuchen