Thread in DLL

[norwegen60]

Hallo zusammen,

ich habe zunächst, wie mal gelernt, folgendes in ein Thread in einer DLL implementiert:

Delphi-Quellcode:

unit thr_IO;
interface

uses
  classes,
  Controls,
  ComCtrls,
  StdCtrls,
  sysUtils,
  ExtCtrls;


type
  TThreadInt64 = procedure(iValue: UInt64) of object;

  TthrIO = CLASS(TThread)
    private
      _iDigIn     : UInt64;
      procedure synciDigInEvent;
    protected
    public
      constructor Create;
      property iDigInEvent: TThreadInt64 read _iDigInEvent write _iDigInEvent;
   end;

implementation

constructor TthrIO.Create;
begin
  inherited Create(true);
end;

procedure TthrIO.execute;
begin
  while not Terminated do
  begin
    Sleep(100);
    GetDigIn;
  end;
end;

procedure TthrIO.GetDigIn;
begin
  _iDigIn := trunc(frac(now*1000)*100000000000);
  Synchronize(synciDigInEvent);   // Hängt sich asf Sobald in DLL . Egal ob Aufruf hier oder in execute
end;

procedure TthrIO.synciDigInEvent;
begin
  if Assigned(_iDigInEvent) then
    _iDigInEvent(_iDigIn);
end;

end.

Die Destrukts habe ich der Übersichtlichkeit halber weg gelassen. Im Quelltext der DLL

Delphi-Quellcode:

library USB1408_DI16;

uses
  Windows,
  SysUtils,
  thr_IO in 'thr_IO.pas';

{$R *.RES}

type
  TUSB1408 = class(TObject)
  private
  public
    iDigIn : UInt64;
    procedure SynciDigIn(iValue:UInt64);
  end;

var
  USB1408 : TUSB1408;
  thrIO   : TthrIO;

procedure TUSB1408.SynciDigIn(iValue:UInt64);
begin
  iDigIn := iValue;
end;


function Init:Boolean; export;

begin
  FreeAndNil(thrIO);
  thrIO := TthrIO.Create;

  thrIO.iDigInEvent    := USB1408.SynciDigIn;

  thrIO.Resume;
end;

function GetBitIn(iKan:Integer):Boolean;
begin
  { DataValue auf den gewünschten bit abfragen und on/off-Status ermitteln }
  Result:=odd(thrIO.iDigIn1 shr iKan);
end;

exports
  Init,
  GetBitIn;

begin
end.

Es hat ein paar Stunden gedauert, bis ich endlich herausgefunden habe, warum der Thread beim Aufruf von Synchronize(synciDigInEvent) sich aufhängt. /Synchronize in DLL´s nicht zulässig ...)

Folgende beide Möglichkeiten funktionieren dagegen.

Delphi-Quellcode:

library USB1408_DI16;
...
function GetBitIn(iKan:Integer):Boolean;
begin
  { DataValue auf den gewünschten bit abfragen und on/off-Status ermitteln }
  Result:=odd(thrIO._iDigIn shr iKan);
end;

wenn iDigIn im Public-Abschnitt definiert wird, oder

Delphi-Quellcode:

protected
      ...
      function GetiDigIn : UInt64;
    public
      ...
      property iDigIn1: UInt64 read GetiDigIn;
    end;

implementation

function TthrIO.GetiDigIn : UInt64;
begin
  Result := _iDigIn;
end;

und der Aufruf im Quelltext der DLL

Delphi-Quellcode:

library USB1408_DI16;
...
function GetBitIn(iKan:Integer):Boolean;
begin
  { DataValue auf den gewünschten bit abfragen und on/off-Status ermitteln }
  Result:=odd(thrIO.iDigIn1 shr iKan);
end;

Und jetzt wüsste ich gerne, ob das so zulässig ist und welche Methode zu bevorzugen wären und wenn, warum

Vielen Dank
Gerd

[himitsu]

Du kannst das Synchronize auch in der EXE belassen und die Funktion, wo das drin ist, von der DLL aus aufrufen.
> als Callback-Methode an die DLL übergeben


Synchronize gehört zur VCL und VCL ist nicht möglich, da DLL und EXE ihre eigene RTTI und eigenen Speichermanager besitzen.
(man könnte jetzt noch anfangen die VCL in der DLL in einem eigenem Thread laufen zu lassen, aber da geht bestimmit irgendwas bei schief)


Oder du arbeites mir RTL/VCL-Packages.

[norwegen60]

Hallo himitsu,

vielen Dank, dass du so schnell geantwortet hast.

Ich hätte vielleicht noch dazu sagen sollen, dass ich auch noch einige Zeit hier rum gesucht habe. Dabei bin ich auf die Möglichkeit des Callbacks gestoßen. Ich werde das auch noch ausprobieren.

Trotzdem wüsste ich gerne, was für oder gegen die obigen Lösungen spricht

Danke
Gerd

[jaenicke]

Synchronize funktioniert in DLLs sehr wohl. Man muss nur eine Prozedur aus der DLL veröffentlichen und im OnIdle des Hostprogramms aufrufen, die CheckSynchronize aufruft. Genau das passiert nämlich dafür im Hostprogramm auch.

Um threadsicher auf solche einzelnen Werte zuzugreifen bieten sich die Interlocked-Funktionen bzw. in aktuellen Delphiversionen die Atomic-Funktionen an:
http://docwiki.embarcadero.com/Libra...micCmpExchange
http://msdn.microsoft.com/en-us/libr...(v=vs.85).aspx