Zitat von Sir Rufo:

Also wir müssen uns hier auf eine korrekte Sprache einigen, denn sonst weiß keiner was wirklich gemeint ist.

Es kommt immer auf den Thread-Kontext an.

Wenn du also bei irgendetwas im Bereich Multithreading Probleme hast, dann ist es sehr wichtig, dass du dabei den Thread-Kontext mit angibst, und nicht welche Form da was aufruft.MainThreadID . Sind die beiden Werte unterschiedlich, dann ist man eben nicht im MainThread-Kontext.

Ich nahm an, dass bei einer Kombination aus dem üblichen Mainform-Prozess und einem Thread keine Verwechslungen durch Vokalwahl auftreten könnten.
Meines Wissens führt der Thread alles selbstständig aus, was über seine Routine Execute verbunden ist und kein Synchronize ist.

Jedenfalls ruft der Hauptprozess eine leere Methode des Threads auf, was zu einem Fehler führt. (siehe oben!)

Zitat von TheGroudonx:

Jedenfalls ruft der Hauptprozess eine leere Methode des Threads auf, was zu einem Fehler führt. (siehe oben!)

Es gibt ja nur einen Prozess und innerhalb dessen mehrere Threads.

Also wer ruft jetzt in welchem Thread-Kontext was auf?

zusammenfalten · markieren

Delphi-Quellcode:

procedure TPaintThread.Execute;
begin
  While (Terminated = False) do
  begin
    try
      Synchronize( Zeichnen );
    finally
    end;
    sleep(1);
  end;
end;

procedure TPaintThread.Zeichnen;
begin
  //
end;

PS
Wenn die TPaintThred.Execute Methode im MainThread-Kontext aufgerufen wird (weil du diese Methode direkt aufrufst), dann ist es kein Wunder, dass du da Probleme bekommst, denn vom MainThread-Kontext aus Synchronize aufrufst, dann kann das zu Problemen führen, wie es auch in der Dokumentation angegeben ist.

Der normale Mainthread-Context erstellt den Thread(TThread)-von da aus läuft alles von selbst weiter.
Der Thread(TThread) ist in einer separaten Unit.
Er(Der Thread) arbeitet seine Execute Methode ab.
Dabei ruft er die Synchronize(Zeichnen) Prozedur auf, durch welche der Mainthread-Context die Zeichen-Routine ausführt.
Dies führt nach Wiederholungen beim Durchsteppen zu einem EAccess-Violation Fehler.
Dieser Fehler passiert, da die Zeichenmethode per Synchronize aufgerufen wird, im Mainthread-Context, wobei die Abbruchstelle am Ende der Zeichenroutine(leer) in der Thread-Unit ist.

Kann ich so nicht nachvollziehen, läuft wie erwartet

EDIT Überwachung des Thread-Kontexts

zusammenfalten · markieren

Delphi-Quellcode:

unit PaintThread;

interface

uses
  Classes;

type
  TPaintThread = class( TThread )

  private
    procedure Zeichnen;
  protected
    procedure Execute; override;
  end;

implementation

uses
  SysUtils,
  Windows;

{ TPaintThread }

procedure TPaintThread.Execute;
begin

  if MainThreadID = GetCurrentThreadId
  then
    raise Exception.Create( 'Upps, ich darf nicht im MainThread-Kontext sein!' );

  inherited;
  while not Terminated do
    begin
      Synchronize( Zeichnen );
      Sleep( 1 );
    end;
end;

procedure TPaintThread.Zeichnen;
begin
  if MainThreadID <> GetCurrentThreadId
  then
    raise Exception.Create( 'Upps, ich bin nicht im MainThread-Kontext!' );

end;

end.

zusammenfalten · markieren

Delphi-Quellcode:

unit FormMain;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics,
  Controls, Forms, Dialogs,
  PaintThread;

type
  TForm1 = class( TForm )
  private
    FPaintThread : TPaintThread;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

var
  Form1 : TForm1;

implementation

{$R *.dfm}
{ TForm1 }

procedure TForm1.AfterConstruction;
begin
  inherited;
  FPaintThread := TPaintThread.Create( False );
end;

procedure TForm1.BeforeDestruction;
begin
  inherited;
  FPaintThread.Free;
end;

end.

Dann ist es entweder die Delphi Version, die den Unterschied macht, oder, was wahrscheinlicher ist, das Durchsteppen wurde nicht so durchgeführt, wie es muss, damit der fehler auftaucht.
Zum Nachvollziehen habe ich ein Video
gelinkt
Es zeigt das Kompilieren, welches am Haltepunkt (Thread-constructor) stoppt, und daraufhin mit F7 gedrückt weiterläuft.

PS: Deine Exception wird nicht angezeigt

Zitat von TheGroudonx:

Dann ist es entweder die Delphi Version, die den Unterschied macht, oder, was wahrscheinlicher ist, das Durchsteppen wurde nicht so durchgeführt, wie es muss, damit der fehler auftaucht.
Zum Nachvollziehen habe ich ein Video
gelinkt
Es zeigt das Kompilieren, welches am Haltepunkt (Thread-constructor) stoppt, und daraufhin mit F7 gedrückt weiterläuft.

Könntest du bitte mal den gesamten Quelltext (Thread und Form) - die wo du den Fehler hast - hier posten?
Und bitte genau den Quelltest und nicht irgendeinen - CopyPaste

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, UThread;

type
  TForm1 = class(TForm)
    Image1: TImage;
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
  private
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  Paintthread : TPaintThread;
  i : Integer;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
Paintthread := TPaintThread.create(false);
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
inc(i);
Paintthread.zeichnen;
end;

end.

zusammenfalten · markieren

Delphi-Quellcode:

unit UThread;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ComCtrls, StdCtrls, ExtCtrls;
    
type
  Image = TImage;
  TPaintThread = class(TThread)



private

    Zeichenflaeche: TImage;

    Original, MyBild : TBitmap;

     i : integer;


  protected

    procedure Execute; override;

  public
                    
    procedure zeichnen;

    constructor Create(CreateSuspended: Boolean);

  end;





implementation





constructor TPaintThread.Create(CreateSuspended: Boolean);
begin
inherited;
end;



procedure TPaintThread.Execute;
begin

 While (Terminated = False) do
 begin

 Synchronize(Zeichnen);
 sleep(1);
 
 end;
end;



procedure TPaintThread.Zeichnen;
begin
inc(i);
end;
end.

zusammenfalten · markieren

Delphi-Quellcode:

program Project1;

uses
  Forms,
  Unit1 in 'Unit1.pas' {Form1},
  UThread in 'UThread.pas';

{$R *.res}

begin
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
end.