Keine Panik, um den "asynchronen Mehrfachaufruf" brauchst du dir eigentlich keinen Kopf machen, solange du das nicht vollmüllst

zusammenfalten · markieren

Delphi-Quellcode:

unit EmbeddedThread;

interface

uses
  System.Classes;

type
  TSubject = class
  private type
    TSubjectData = record
      Value : Integer;
    end;

    TWorkThread = class( TThread )
    private
      FSubject : TSubject;
      FData : TSubjectData;
    protected
      procedure Execute; override;
      procedure QueueData;
    public
      constructor Create( ASubject : TSubject );
    end;
  private
    FWorkThread : TWorkThread;
    FData : TSubjectData;
    FOnChange : TNotifyEvent;
    procedure SetData( const Value : TSubjectData );
    procedure DoNotifyChange;
    function GetValue : Integer;
  public
    constructor Create;
    destructor Destroy; override;

    property Value : Integer read GetValue;
    property OnChange : TNotifyEvent read FOnChange write FOnChange;
  end;

implementation

{ TSubject.TWorkThread }

constructor TSubject.TWorkThread.Create( ASubject : TSubject );
begin
  inherited Create( False );
  FSubject := ASubject;
end;

procedure TSubject.TWorkThread.Execute;
var
  LStep : Integer;
begin
  inherited;
  while not Terminated do
  begin
    Sleep( 250 );

    if FData.Value = 100 then
      LStep := - 1
    else if FData.Value = 0 then
      LStep := 1;

    FData.Value := FData.Value + LStep;
    QueueData;
  end;
end;

procedure TSubject.TWorkThread.QueueData;
begin
  Queue(
      procedure
    begin
      FSubject.SetData( FData );
    end );
end;

{ TSubject }

constructor TSubject.Create;
begin
  inherited;
  FWorkThread := TWorkThread.Create( Self );
end;

destructor TSubject.Destroy;
begin
  FWorkThread.Free;
  inherited;
end;

procedure TSubject.DoNotifyChange;
begin
  if Assigned( OnChange ) then
    OnChange( Self );
end;

function TSubject.GetValue : Integer;
begin
  Result := FData.Value;
end;

procedure TSubject.SetData( const Value : TSubjectData );
begin
  FData := Value;
  DoNotifyChange;
end;

end.

Ich weiß nicht ob ich es falsch verstanden habe oder sonstwas, aber gibt es für sowas nicht auch noch die CriticalSections? Oder können die in diesem Fall nicht benutzt werden?

Zitat von Aviator:

Ich weiß nicht ob ich es falsch verstanden habe oder sonstwas, aber gibt es für sowas nicht auch noch die CriticalSections? Oder können die in diesem Fall nicht benutzt werden?

Theoretisch ja, aber beim Zugriff über eine CS kann der WorkerThread ausgebremst werden.

Danke für die Info. Jetzt weiß ich aber auch was mit CS gemeint war

Zitat von Sir Rufo:

Keine Panik, um den "asynchronen Mehrfachaufruf" brauchst du dir eigentlich keinen Kopf machen, solange du das nicht vollmüllst

markieren

Delphi-Quellcode:

unit EmbeddedThread;

... snip ...
end.

Um es mit Terry Pratchett zu sagen: Potzblitz! Ja die Anregung mit Queue und Workerthread ist toll und sollte auch viel durch das Weglassen der CS erheblich performanter sein
Danke vielmals und Grüße,

Peter

Problem ist nur, das Du dann u.U. den Hauptthread zumüllst, wenn Du deine Controls zu oft ansprichst (also 'Queue' zu oft aufrufst). Das Resultat ist dann ein flüssig laufender Hintergrundthread mit einer stockenden und u.U. für Minuten blockierten UI.

Zitat von Buddelfish:

Problem ist nur, das Du dann u.U. den Hauptthread zumüllst, wenn Du deine Controls zu oft ansprichst (also 'Queue' zu oft aufrufst). Das Resultat ist dann ein flüssig laufender Hintergrundthread mit einer stockenden und u.U. für Minuten blockierten UI.

Das ist klar - das kürzeste visuelle Update im Störfall findet nach 25 ms statt (schneller "sehen" wir ja nichts...), in der Regel checke ich die Maschinenstati wie Produktgeschwindigkeit ein mal pro Sekunde pro Gerät. Aber mal sehen, wie es sich ergibt.

Und da ich alle Elemente wie Checkboxen, Radiobuttons, div Buttons, Edits, etc von TControl abgeleitet nachgebaut habe, geht das Zeichnen recht flott und FMX macht meist das, was ich will

Hmm.. Queue scheint nicht aufgerufen zu werden... mit Synchronize funktionierts...

Vorgang: Der asynchrone Thread, der die Daten von externen Schnittstellen entgegennimmt, erzeugt pro Änderung / Durchlauf einen Workerthread.
Der Workerthread triggert eine Routine des Owners, der wiederum einen Event nach aussen legt. Mit Synchronize wird der Workerthread im Hauptthread ausgeführt, während der asynchrone Thread weiterläuft.

markieren

Code:

  (****************************************************************************)
  (** TG6BxWorkerThread                                                     **)
  (** ==================                                                    **)
  (** BX Workerthread                                                       **)
  (** Wird innerhalb des CmdRWThread erzeugt.                               **)
  (** Dieser Thread dient dazu, via MainThread Bildschirmausgaben zu        **)
  (** aktualisieren.                                                        **)
  (****************************************************************************)
  TG6BxHeadStatusThread = Class (TThread)
    fOwner                                                : TG6BXTarget;
    fHeadStatus                                           : TG6BxHeadStatus; (** TPersistent **)
    procedure Execute; override;
  public
    constructor Create (AOwner: TG6BXTarget; AHeadStatus : TG6BxHeadStatus);
    destructor Destroy; override;
  end;

(******************************************************************************)
(******************************************************************************)
(** TG6BxWorkerThread                                                       **)
(******************************************************************************)
(******************************************************************************)
constructor TG6BxHeadStatusThread.Create (AOwner: TG6BXTarget; AHeadStatus : TG6BxHeadStatus);

  begin
    inherited Create(False);
    fHeadStatus := TG6BxHeadStatus.Create;
    fHeadStatus.Assign(AHeadStatus);
    (** Init **)
    FOwner              := AOwner;
    Self.FreeOnTerminate := True;
  end;
(******************************************************************************)
destructor TG6BxHeadStatusThread.Destroy;

  begin
    FreeAndNil(fHeadStatus);
    inherited Destroy;
  end;
(******************************************************************************)
procedure TG6BxHeadStatusThread.Execute;

  begin
    synchronize(procedure
                  begin
                    if fOwner <> nil then fOwner.UpdateExternalHeadStatus(fHeadStatus);
                  end
                );
  end;

@Sir Rufo
Vielen Dank für diesen hervorragenden Code Schnipsel! Ich arbeite zwar in einem ganz anderen Kontext (Trackbar Komponente für einen Videoplayer), aber mit diesem Beispiel wurden stundenlange Recherchen sowie diverse Fehlermeldungen und Abstürze endlich erfolgreich gelöst. Warum steht sowas nicht in der Delphi Hilfe...

Danke!