Hi,

Ich habe einen Thread in den eine Componente erzeugt wird, wenn der Thread läuft wird bleibt das Programm stehen, dabei wird die Komponente mit Owner nil erzeugt, und im Thread wird alles mit Synchronize auf gerufen...

Warum bleibt das Hauptprogramm stehen ?

thx, Björn

Kannst du uns bitte etwas Code zeigen?

Jo:

zusammenfalten · markieren

Delphi-Quellcode:

unit GLSI_DataModule;

interface

uses
  SysUtils, Classes, JvComponent, JvInterpreter_all, JvInterpreter;

type
  TInterpreterhread = class(TThread)
  protected
    procedure Execute; override;
  private
    PSender: TObject;
    PIdentifier: String;
    PValue: Variant;
    PArgs: TJvInterpreterArgs;
    PDone: Boolean;
  public
    Interpreter: TJvInterpreterProgram;
    procedure InterpreterGetValue(Sender: TObject; Identifier: String;
      var Value: Variant; Args: TJvInterpreterArgs; var Done: Boolean);
    procedure SyncGetValue();
    destructor Destroy; override;
  end;

type
  TGLSInterpreterModule = class(TDataModule)
    Interpreter: TJvInterpreterProgram;
    procedure InterpreterGetUnitSource(UnitName: String;
      var Source: String; var Done: Boolean);
    procedure InterpreterGetValue(Sender: TObject; Identifier: String;
      var Value: Variant; Args: TJvInterpreterArgs; var Done: Boolean);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    Thread: TInterpreterhread;
    Lines: TStringList;
    procedure CompileCode;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;

var
  GLSInterpreterModule: TGLSInterpreterModule;

implementation

{$R *.dfm}

{ TInterpreterhread }

procedure TInterpreterhread.Execute;
begin
  Interpreter.Compile;
  Interpreter.CallFunction('main', nil, []);
end;

{ TGLSInterpreterModule }

procedure TGLSInterpreterModule.CompileCode;
begin
  Thread:= TInterpreterhread.Create(True);
  Thread.Interpreter:= TJvInterpreterProgram.Create(nil);
  Thread.Interpreter.Pas.Clear;
  Thread.Interpreter.Pas.AddStrings(Lines);
  Thread.Interpreter.OnGetValue := Thread.InterpreterGetValue;
  Thread.Execute;
end;

procedure TInterpreterhread.InterpreterGetValue(Sender: TObject;
  Identifier: String; var Value: Variant; Args: TJvInterpreterArgs;
  var Done: Boolean);
begin
  if (AnsiSameText(Identifier, 'delay'))or
     (AnsiSameText(Identifier, 'sleep')) then
  begin
    sleep(Args.Values[0]);
    Done := true;
    exit;
  end else begin
    PSender := Sender;
    PIdentifier := Identifier;
    PValue := Value;
    PArgs := Args;
    PDone := Done;
    Synchronize(SyncGetValue);
    Done := PDone;
    Value := PValue;
  end;
end;

procedure TInterpreterhread.SyncGetValue();
begin
  GLSInterpreterModule.InterpreterGetValue(
      PSender, PIdentifier, PValue, PArgs, PDone);
end;

procedure TGLSInterpreterModule.InterpreterGetValue(Sender: TObject;
  Identifier: String; var Value: Variant; Args: TJvInterpreterArgs;
  var Done: Boolean);
begin
  //
end;

*push*

(jetzt darf ich wohl)

wer ist denn der TInterpreter?!hread?

Nur zur Sicherheit, bitte nicht hauen:

Du erzeugst den Thread mit CreateSuspended = false oder startest ihn mit Resume und rufst NICHT ETWA Thread.Execute aus dem Mainthread heraus direkt auf? (obwohl das ja eigentlich sowieso protected sein sollte, oder? Ich seh jetzt hier aauch nirgends ein Execute; override; ?!

Hast du den Code hier reingetippt? Ich kann mir nicht vorstellen, dass der so kompiliert...

Nun ich habe ihn tatsächlich mit Execute aufgerufen

Habe das jetzt geändert...

zusammenfalten · markieren

Delphi-Quellcode:

procedure TInterpreterhread.Execute;
begin

  Interpreter:= TJvInterpreterProgram.Create(nil);
  Interpreter.Pas.Clear;
  Interpreter.Pas.AddStrings(GLSInterpreterModule.Lines);
  Interpreter.OnGetValue := InterpreterGetValue;

  Interpreter.Compile;
  Interpreter.CallFunction('main', nil, []);
end;

{ TGLSInterpreterModule }

procedure TGLSInterpreterModule.CompileCode;
begin
  Thread:= TInterpreterhread.Create(False);
end;

Nur leider stürzt nun das gesamte Programm komplett ab (mit Delphi)

TInterpreter ist eine NonVisuele Komponente

Öhm... abstürzen sollte es nicht. Greifst du irgendwo auf Daten des hauptthreads zu? Die nichtvisuelle Komponente sollte eigentlcih auch keine Probleme machen, außer sie benutzt das Windows-Messaging. marabu hat da mal einen tollen Trick gezeigt:

TJvInterpreter.Create(THandle(-3)); Irgendwie erzeugt man damit ein Message-Only-Window... aber frag ihn wegen details

Ja einmal: Interpreter.Pas.AddStrings(GLSInterpreterModule.Lines); Was muss man da denn beachten ?

Naja, dass nicht zur selben Zeit der hauptthread versucht zuzugreifen und dass die instanz initialisiert ist.

So übergebe jetzt die Daten im constructor, aber wenn ich das Teil starte bleibt alles stehen und es kommmt eine Exception des Types "" mit der meldung "" (hat ich auch noch nie )

Aber der Trick mit den Handle klapt nicht der will ne TComponent haben