TThread.Queue landet nicht in der Queue

[Sir Rufo]

Zitat von himitsu:

Das ist ja grade falsch, denn vom Hauptthread aus aufgerufen ist diese Funktion "blockierend", da sie dort erst zurück kehrt, wenn der enthaltene Code abgearbeitet wurde.

Und genau das sollte nicht passieren ... jedenfalls war das so nicht von mir geplant/erhofft.
Hatte halt "erwartet", daß die Funktion auch da genauso ist, wie aus anderen Threads.

Es gibt halt keinen noch mainigeren Thread über dem MainThread. Und sobald sich das im MainThread-Kontext befindet, wird es aufgerufen. Beim Aufruf ist es in dem Kontext, also wird es auch direkt ausgeführt.

Eventuell suchst du ja so was

Delphi-Quellcode:

unit uLater;

interface

uses
  System.Generics.Collections,
  System.SysUtils,
  System.SyncObjs,
  System.Classes;

type
  Later = class
  private type
    TProcItem = record
      Proc : TProc;
      constructor Create( AProc : TProc );
    end;

    TLaterThread = class( TThread )
    private
      FCS : TCriticalSection;
      FEvent : TEvent;
      FQueue : TQueue<TProcItem>;
    private
      function GetProc : TProcItem;
    protected
      procedure Execute; override;
      procedure TerminatedSet; override;
    public
      constructor Create;
      destructor Destroy; override;

      procedure AddProc( AProc : TProc );
    end;
  private
    class var FThread : TLaterThread;
  protected
    class constructor Create;
    class destructor Destroy;
  public
    class procedure Execute( AProc : TProc );
  end;

implementation

{ Later }

class constructor Later.Create;
begin
  FThread := TLaterThread.Create;
end;

class destructor Later.Destroy;
begin
  FThread.Free;
end;

class procedure Later.Execute( AProc : TProc );
begin
  FThread.AddProc( AProc );
end;

{ Later.TLaterThread }

procedure Later.TLaterThread.AddProc( AProc : TProc );
begin
  FCS.Enter;
  try
    FQueue.Enqueue( TProcItem.Create( AProc ) );
    FEvent.SetEvent;
  finally
    FCS.Leave;
  end;
end;

constructor Later.TLaterThread.Create;
begin
  inherited Create( False );
  FCS := TCriticalSection.Create;
  FEvent := TEvent.Create( nil, True, False, '' );
  FQueue := TQueue<TProcItem>.Create;
end;

destructor Later.TLaterThread.Destroy;
begin
  FCS.Enter;
  try
    FQueue.Free;

    inherited;
    FEvent.Free;
  finally
    FCS.Leave;
    FreeAndNil( FCS );
  end;
end;

procedure Later.TLaterThread.Execute;
var
  LProc : TProcItem;
begin
  inherited;
  while not Terminated do
  begin
    if ( FEvent.WaitFor( INFINITE ) = TWaitResult.wrSignaled ) and not Terminated then
    begin
      LProc := GetProc;
      Queue(
          procedure
        begin
          LProc.Proc( );
        end );
    end;
  end;
end;

function Later.TLaterThread.GetProc : TProcItem;
begin
  FCS.Enter;
  try
    Result := FQueue.Dequeue;
    if FQueue.Count = 0 then
      FEvent.ResetEvent;
  finally
    FCS.Leave;
  end;
end;

procedure Later.TLaterThread.TerminatedSet;
begin
  inherited;
  FEvent.SetEvent;
end;

{ Later.TProcItem }

constructor Later.TProcItem.Create( AProc : TProc );
begin
  Proc := AProc;
end;

end.

Dann kannst du damit

Delphi-Quellcode:

procedure TForm1.Button2Click( Sender : TObject );
begin
  ListBox1.Items.Add( 'first' );

  Later.Execute(
      procedure
    begin
      ListBox1.Items.Add( 'second' );
    end );

  ListBox1.Items.Add( 'third' );
end;

und in der ListBox kommt an

Code:

first
third
second

[Sir Rufo]

Es gibt auch noch eine ganz billige Methode ohne Thread. Dabei wird der Code am Ende der Methode/Prozedur ausgeführt:

Delphi-Quellcode:

  ILater = interface
    ['{CF68F59B-FA67-4915-B1DB-F3DAA1A3D929}']
  end;

  TLater = class( TInterfacedObject, ILater )
  private
    FProc : TProc;
  protected
    constructor Create( AProc : TProc );
  public
    class function Execute( AProc : TProc ) : ILater;
    destructor Destroy; override;
  end;

{ TLater }

constructor TLater.Create( AProc : TProc );
begin
  inherited Create;
  FProc := AProc;
end;

destructor TLater.Destroy;
begin
  FProc( );
  inherited;
end;

class function TLater.Execute( AProc : TProc ) : ILater;
begin
  Result := TLater.Create( AProc );
end;

allerdings werden die in umgekehrter Reihenfolge der Erstellung abgearbeitet

Delphi-Quellcode:

procedure TForm1.Button2Click( Sender : TObject );
begin
  ListBox1.Items.Add( 'first' );

  TLater.Execute(
      procedure
    begin
      ListBox1.Items.Add( 'second' );
    end );

  TLater.Execute(
      procedure
    begin
      ListBox1.Items.Add( 'third' );
    end );

  ListBox1.Items.Add( 'fourth' );
end;

und in der Listbox steht

Code:

first
fourth
third
second

[himitsu]

Da ist es noch nie zu einer Endlosschleife gekommen ... ich wüsste jetzt auch nicht, wie es dazu kommen sollte.
OK, ich könnte mir eventuell denken, wie es dazu kommen könnte, aber das liegt halt an dem "falschen" Verhalten. (würde nicht passieren, wenn es "richtig" funktionieren würde )

Zitat von Sir Rufo:

Es gibt auch noch eine ganz billige Methode ohne Thread. Dabei wird der Code am Ende der Methode/Prozedur ausgeführt:

Ist noch zu früh ... erstmal muß der ganze DevExpress- und VCL-Rotz "hinter" dem END auch noch ausgeführt werden, weil es sonst knallt.

Sieht bei mir praktisch so aus.
Heißt nur deshalb nicht .Queue, damit der Compiler meckert, wenn man vergessen hat die Unit mit dem Helper einzubinden.

Delphi-Quellcode:

type
  TThreadHelper = class helper for TThread
  public
    {$REGION 'Documentation'}
    ///   <summary>
    ///     BUGFIX: Da TThread.Queue vom Hauptthread aus nicht in der Queue landet, sondern sofort ausgeführt wird.
    ///   </summary>
    {$ENDREGION}
    class procedure Queue_Bugfix(AThread: TThread; AThreadProc: TThreadProcedure); overload; static;
  end;

class procedure TThreadHelper.Queue_Bugfix(AThread: TThread; AThreadProc: TThreadProcedure);
begin
  if (MainThreadID = CurrentThread.ThreadID) and not Assigned(AThread) then begin
    // wenn im Hauptthread aufgerufen, dann an Thread übergeben
    // die **** führen das sonst sofort aus, anstatt es an die Queue zu übergeben
    CreateAnonymousThread(procedure
      begin
        try
          Queue(AThread, AThreadProc);
        except
          on E: Exception do
            ShowException(E, nil);
        end;
      end).Start;
  end else
    Queue(AThread, AThreadProc);
end;

[BUG]

Man könnte die Semantik von Queue so sehen: Eine an Queue übergebene Prozedur wird zu einem beliebigen Zeitpunkt nach dem Aufruf im Hauptthread ausgeführt.
Dein eigentliches Problem ist (mit etwas Schielen) eine Race-Condition mit dem Code, der nach Queue ausgeführt wird. Analog gibt es dieses Problem auch aus anderen Threads, nur da achtest du mehr darauf.

Zitat von himitsu:

Sieht bei mir praktisch so aus.

Das ist aber schon ein ziemlicher Hammer, für solche Workarounds einen zusätzlichen Thread zu benutzen.

[Der schöne Günther]

Nur wie gesagt, ich bin da jetzt kein Spezialist für, aber je nachdem, wie "async"-verdorben man schon ist und wie oft man so etwas macht, wäre es vielleicht besser, sich einmal so einen Thread anzulegen, der dann dafür immer mittels Event aufgeweckt wird. Vielleicht noch den "Delay", wann es reingequeued wird, einstellbar machen

Aber ganz ehrlich, ja, so mache ich das auch

Application.OnIdle habe ich mir noch nicht angeschaut. Gibt das vielleicht noch etwas tolles her?

[himitsu]

Ja, der Code ist halt schön kurz/einfach.

Aber dafür wird das auch sehr selten, wenn überhaupt, aufgerufen.

[Der schöne Günther]

Zitat von Sir Rufo:

Eventuell suchst du ja so was

Ich finde deine Implementation von TerminatedSet verdient nochmal besondere Beachtung: Der Thread schläft und wartet auf das Event. Ruft man meinThread.Terminate() auf passiert nichts, da er schläft. Das Setzen des Events weckt ihn auf und er merkt, dass seine Zeit gekommen ist.

TThread.Terminate() ist nicht virtuell, wohl aber die undokumentierte Methode TerminatedSet() . Eigentlich ein Musterbeispiel (für TThread und für fehlende Doku an sich )