Hallo,

Also ich habe ein Objekt auf das ich sowohl in einem Thread als auch im MainThread zugreife.
Kann das gutgehen? Dabei muss ich sagen, dass im MainThread nie Methoden aufgerufen werden, die der Thread aufruft.

Ich kann mal ein paar Schnipsel Code zeigen. Wobei der Code in der Execute Methode nicht 1:1 der gleiche ist wie im Original. Aber ggf. kann ich auch den Originalcode posten, wenn das nötig sein sollte.

zusammenfalten · markieren

Delphi-Quellcode:

type
  // Der Thread
  TClientThread = class(TThread)
  private
    // Auf das Objekt wird von anderer Stelle im MainThread zugegriffen
    FClient: TJClient;
  protected
    procedure Execute; override;
  public
    constructor Create(AClient: TJClient); reintroduce;
  end;

// Im MainThread wird niemals auf
// - FClient.Connected
// - FClient.InputBufferIsEmpty
// - FClient.InputBuffer
// - FClient.ReadBytes
// - FClient.FBuffer
//
// zugegriffen.

procedure TClientThread.Execute;
var Buff: TBytes;
begin
  while not Terminated do
  begin
    if not FClient.Connected then continue;

    if not FClient.InputBufferIsEmpty then
    begin
      FClient.ReadBytes(Buff,FClient.InputBuffer.Size);
      FClient.FBuffer.Write(Buff[0],Length(Buff));
      Synchronize(FClient.ReceiveData);
    end;
    sleep(1);
  end;
end;

Wenn ich Code von TJClient o.ä. posten soll, dann sagt Bescheid.

Gruß
Neutral General

Kannst ja jede Methode mit einer CriticalSection sichern, sodass TJClient threadsafe wird. Wichtig dabei ist immer, dass Variable mit einer Setter- und Getter-Methode versehen wird.

Welche Methoden jeweils aufgerufen werden ist egal

Du muß gemeinsam genutzte und nicht threadsichere Variablen/Resourcen gegeneinander absichern.

Beispiel

zusammenfalten · markieren

Delphi-Quellcode:

// threadsave

// Thread 1 greift nur auf Proc zu
// Thread 2 greift nur auf Proc zu

type TMayClass = class
    A, B: Integer;
    procedure ProcA;
    procedure ProcB;
  end;

procedure TMyClass.ProcA;
begin
  Inc(A);
end;

procedure TMyClass.ProcB;
begin
  Inc(B);
end;

zusammenfalten · markieren

Delphi-Quellcode:

// NICHT threadsave

// Thread 1 greift nur auf ProcA zu
// Thread 2 greift nur auf ProcB zu

type TMayClass = class
    X: Integer;
    procedure ProcA;
    procedure ProcB;
  end;

procedure TMyClass.ProcA;
begin
  Inc(X);
end;

procedure TMyClass.ProcB;
begin
  Inc(X);
end;

// aber so wäre es threadsave

var CS: TCriticalSection;

// Thread 1
CS.Enter;
try
  MyClass.ProcA;
finally
  CS.Leave;
end;

// Thread 2 genauso
...

zusammenfalten · markieren

Delphi-Quellcode:

// threadsave

// Thread 1 greift nur auf Proc(1) zu
// Thread 2 greift nur auf Proc(2) zu

type TMayClass = class
    A, B: Integer;
    procedure Proc(i: Integer);
  end;

procedure TMyClass.Proc(i: Integer);
begin
  if i = 1 then Inc(A) else Inc(B);
end;

Zitat von himitsu:

Welche Methoden jeweils aufgerufen werden ist egal

Du muß gemeinsam genutzte und nicht threadsichere Variablen/Resourcen gegeneinander absichern.

Wie mache ich das?

Hier findest ein Beispiel.

Hier findest Infos von Luckie zum Thema. Vor allem das Thema Kritische Abschnitte ist hierbei empfehlenswert.

Zitat von Neutral General:

Wie mache ich das?

Indem du Aufrufe von FClient, welche gemeinsame Dinge nutzen könnten, z.B. mit einer CriticalSection absicherst.

siehe mein Editiertes: Ende vom zweiten Beispiel

Ehm also.. das heißt ich mache einfach folgendes:

zusammenfalten · markieren

Delphi-Quellcode:

// als privates Feld z.B.
var CS: TCriticalSection;

procedure TClientThread.Execute;
var Buff: TBytes;
begin
  while not Terminated do
  begin
    CS.Enter;
    try
      if not FClient.FTCPClient.Connected then continue;

      if not FClient.FTCPClient.Socket.InputBufferIsEmpty then
      begin
        FClient.FTCPClient.Socket.ReadBytes(Buff,FClient.FTCPClient.Socket.InputBuffer.Size);
        FClient.FBuffer.Write(Buff[0],Length(Buff));
        Synchronize(FClient.ReceiveData);
      end;
    finally
      CS.Leave;
    end;
    sleep(5);
  end;
end;

und alles ist gut?

Also ich hab es immer so verstanden, dass ich das in die entsprechende Methode packe, die von mehrere Threads aufgerufen wird. Wenn ein Thread in die Kritische Sektion eingetreten ist, so muss jeder andere warten, bis dieser diese Sektion wieder verlassen hat.

@himitsu: Bist du sicher, dass das hier passt?

zusammenfalten · markieren

Delphi-Quellcode:

var CS: TCriticalSection;

// Thread 1
CS.Enter;
try
  MyClass.ProcA;
finally
  CS.Leave;
end;

// Thread 2 genauso
...

@Neutral General: Somit wäre dein Code nicht richtig.

Neutral General's Code müsste doch klappen, wenn das alles im Thread ist und in der Form auch CS.Enter und Leave am Selben TCriticalSection-Objekt aufgerufen wird?

Zitat von Neutral General:

markieren

Delphi-Quellcode:

..
        Synchronize(FClient.ReceiveData); //<=========
      end;
    finally
      CS.Leave; //<=========
    end;

Unter der Vorraussetzung das ReceiveData auch per CS.Enter zugreifen will (z.B. auf FBuffer) ist das ein klassischer Deadlock, da der Thread die CS noch hält.

Wenn der MainThread nur auf die in FBuffer bereitgestellten Daten zurückgreift muss auch nur der Zugriff auf FBuffer synchronisiert werden, das schafft mehr Atempausen in denen die einzelnen Threads frei arbeiten können:

zusammenfalten · markieren

Delphi-Quellcode:

    ..
    if not FClient.FTCPClient.Connected then continue;

    if not FClient.FTCPClient.Socket.InputBufferIsEmpty then
    begin
      FClient.FTCPClient.Socket.ReadBytes(Buff,FClient.FTCPClient.Socket.InputBuffer.Size);
      CS.Enter;
      try
        FClient.FBuffer.Write(Buff[0],Length(Buff));
      finally
        CS.Leave;
      end;
      Synchronize(FClient.ReceiveData);
    end;
    ..

Grüsse, Dirk