TThread.Queue landet nicht in der Queue

[himitsu]

Moin,

nur weil ich mal TThread.Queue vom Hauptthread ausrufe, kommen die Idioten auf die blöde Idee das sofort auszuführen.


Wenn ich will, das das nicht sofort ausgeführt wird, dann hast es das gefälligst auch nicht zu tun.

Im Grunde sollte das doch erst ausgeführt werden, wenn der Hauptthread das aus seiner Queue (MessageQueue) zieht, bzw. wenn jemand explitit Application.ProcessMessages aufruft,
so wie es das auch macht, wenn man es aus einem anderen Thread heraus aufruft.



Seh nur ich das als BUG, oder soll der Sch*** so sein?

[Uwe Raabe]

Dann hast den Sinn von TThread.Queue offenbar anders verstanden. Queue ist im Gegensatz zu Synchronize ein nicht-blockierender Aufruf der übergebenen Methode im Hauptthread. Sowohl Synchronize als auch Queue führen die Methode immer dann direkt aus, wenn sie aus dem Hauptthread heraus aufgerufen werden. Das ist m.E. durchaus logisch und nachvollziehbar. Das hat erstmal überhaupt nichts mit der Windows-Message-Queue zu tun.

[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.

[Der schöne Günther]

Harte Worte, harte Herzen.

Aber hat mich auch schon gewundert. Ich habe mir immer einen anonymen Thread erstellt (und gestartet) der nichts anderes macht, als den Kram wieder in den Hauptthread zurück-zu-queuen. Ressourcenschonend ist das nicht aber naja.

Aber wahrscheinlich baut man sich besser selber eine eigene Queue und arbeitet die im Application.OnIdle oder sowas ab.

[himitsu]

Zitat von Der schöne Günther:

Ich habe mir immer einen anonymen Thread erstellt ...

Rate mal, was ich mir auch erstmal schnell, als BUGFIX via ClassHelper an TThread gehängt hatte? (da sich TThread.Queue natürlich nicht überschreiben lies)

[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

[mjustin]

Zitat von himitsu:

Seh nur ich das als BUG, oder soll der Sch*** so sein?

Das is "as designed", a.k.a. "das soll so sein":

Zitat:

Warnung: Rufen Sie Queue nicht aus dem Haupt-Thread aus auf. Dies kann zu einer Endlosschleife führen.

http://docwiki.embarcadero.com/Libra....TThread.Queue

[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.