AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Sprachen und Entwicklungsumgebungen Sonstige Fragen zu Delphi Delphi Mutex-Handling in DLL für zwei Programme

Mutex-Handling in DLL für zwei Programme

Ein Thema von TheSledgeHammer · begonnen am 22. Mai 2019 · letzter Beitrag vom 23. Mai 2019
Antwort Antwort
TheSledgeHammer

Registriert seit: 22. Mai 2019
Ort: Mulfingen
5 Beiträge
 
Delphi 10.1 Berlin Enterprise
 
#1

Mutex-Handling in DLL für zwei Programme

  Alt 22. Mai 2019, 13:18
Hallo Community,

ich sitze hier gerade an einem sehr "interessanten" (man könnte auch nervig dazu sagen...) Phänomen, das ich mir nicht so recht erklären kann.

Zunächst mal kurz die Motivation:
Es gibt hier zwei Prozesse, die sich eine INI-Datei teilen. Der eine Prozess ist eine EXE-Datei in Delphi geschrieben (32 bit), der andere ist ein Matlab-Skript. Beide Prozesse schreiben und lesen diese INI-Datei, daher ist eine Synchronisation absolut notwendig. Das wollte ich mit einer DLL realisieren, die einen Mutex erzeugt. Eine DLL deshalb, weil Matlab wohl das Prinzip der Mutexe nicht unterstützt und ich dem Entwickler somit dieselbe Funktionalität zur Verfügung stellen kann.

Es gibt 4 Methoden, die die DLL zur Vefügung stellt: Register, UnRegister, Acquire und Release. In der DLL wiederum gibt es eine globale Variable FMutex (Vom Typ System.SyncObj.TMutex), die über die komplette Laufzeit hinweg gehalten wird. Register macht ein Create, UnRegister ein Free und Acquire bzw. Release sind ja selbsterklärend.

Jetzt kommt der Clou: Wenn ich diese 4 Methoden einfach im Delphi-Programm "hart rein programmiere", dann klappt das alles wie am Schnürchen. Sobald diese Methoden aber in der DLL stehen und aufgerufen werden, fliegt mir das Programm um die Ohren wie eine Kuh bei einem Tornado.

Hier mal die DLL:
Delphi-Quellcode:
uses
  System.SysUtils,
  System.Classes,
  System.SyncObjs;

{$R *.res}

var
  FMutex: TMutex;

procedure RegisterMutex(); stdcall;
begin
  if not Assigned(FMutex) then
    FMutex := TMutex.Create(nil, false, 'MyUniqueMutexName');
end;

procedure UnRegisterMutex(); stdcall;
begin
  if Assigned(FMutex) then
    FMutex.Free;
end;

procedure AcquireMutex(); stdcall;
begin
  if Assigned(FMutex) then
    FMutex.Acquire;
end;

procedure ReleaseMutex(); stdcall;
begin
  if Assigned(FMutex) then
    FMutex.Release;
end;

exports
  RegisterMutex,
  UnRegisterMutex,
  AcquireMutex,
  ReleaseMutex;

begin
end.
In dem Delphi-Programm, das ich auch entwickle, lade ich die DLL mittels LoadLibrary und hole mir die 4 Methoden über GetProcAddress. Die rufe ich dann an den entsprechenden Stellen auf.

Hat irgendwer von euch schon Mal so ein Konstrukt gebaut oder verwendet?
Tobias

Geändert von TheSledgeHammer (22. Mai 2019 um 14:21 Uhr)
  Mit Zitat antworten Zitat
dummzeuch

Registriert seit: 11. Aug 2012
Ort: Essen
426 Beiträge
 
Delphi 2007 Professional
 
#2

AW: Mutex-Handling in DLL für zwei Programme

  Alt 22. Mai 2019, 13:48
Jetzt kommt der Clou: Wenn ich diese 4 Methoden einfach im Delphi-Programm "hart rein programmiere", dann klappt das alles wie am Schnürchen. Sobald diese Methoden aber in der DLL stehen und aufgerufen werden, fliegt mir das Programm um die Ohren wie eine Kuh bei einem Tornado.
Was genau ist der Fehler? Ich glaube kaum, dass beim Start des Programms starker Wind auftritt und vierbeinige Nutztiere durch die Gegend fliegen.
Thomas Mueller
  Mit Zitat antworten Zitat
TheSledgeHammer

Registriert seit: 22. Mai 2019
Ort: Mulfingen
5 Beiträge
 
Delphi 10.1 Berlin Enterprise
 
#3

AW: Mutex-Handling in DLL für zwei Programme

  Alt 22. Mai 2019, 14:05
Nein, auch wenn wir hier Geräte herstellen, die durchaus genug Wind erzeugen könnten, damit so etwas passiert, ist das nicht der Fall

Das schöne (oder eher schlimme) ist, dass keine Fehlermeldung erscheint, sonst hätte ich sie ja mit dazu geschrieben. Aus Sicht des Anwenders kommt aus heiterem Himmel "Programm reagiert nicht mehr und muss geschlossen werden". Ich habe den Absturz zwar lokalisieren können, aber es macht keinen wirklichen Sinn:

Nach dem Laden der DLL wird die Register-Funktion aufgerufen (klappt), danach kommt ein Acquire (geht auch noch) und ein Release (klappt auch) und selbst das UnRegister scheint zu klappen (laut Debug-Ausgaben). Nur in dem Moment, in dem die UnRegister Funktion verlassen wird, knallt's.
Tobias
  Mit Zitat antworten Zitat
TiGü

Registriert seit: 6. Apr 2011
Ort: Berlin
2.109 Beiträge
 
Delphi 10.2 Tokyo Enterprise
 
#4

AW: Mutex-Handling in DLL für zwei Programme

  Alt 22. Mai 2019, 14:11
Minimales Beispielprojekt zum Nachvollziehen?
  Mit Zitat antworten Zitat
TheSledgeHammer

Registriert seit: 22. Mai 2019
Ort: Mulfingen
5 Beiträge
 
Delphi 10.1 Berlin Enterprise
 
#5

AW: Mutex-Handling in DLL für zwei Programme

  Alt 22. Mai 2019, 14:19
Minimales Beispielprojekt zum Nachvollziehen?
Ich werde mal die Methoden hier rein schreiben, die notwendig wären, das wird so 1:1 nicht laufen.

Delphi-Quellcode:

TMyDllProc = procedure() of object; stdcall;

TExampleClass = class(TThread)
  private
    FHandleDLL: THandle;
    // methods from DLL
    FRegister: TMyDllProc;
    FUnRegister: TMyDllProc;
    FAcquire: TMyDllProc;
    FRelease: TMyDllProc;

    function InitMutexDLL(): boolean;
    procedure DeInitMutexDLL();
    procedure ExecuteMutex();

    procedure Execute(); override;
end;

// ...

function TExampleClass.InitMutexDLL(): boolean;
begin
 
  Result := false;
  FHandleDLL := LoadLibrary(PChar('MutexDLL.dll'));

  if FHandleDLL <> INVALID_HANDLE_VALUE then
  begin

    @FRegister := GetProcAddress(FHandleDLL, 'RegisterMutex');
    @FAcquire := GetProcAddress(FHandleDLL, 'EnterMutex');
    @FRelease := GetProcAddress(FHandleDLL, 'ReleaseMutex');
    @FUnregister := GetProcAddress(FHandleDLL, 'UnRegisterMutex');

    Result := Assigned(FRegister) and Assigned(FAcquire) and Assigned(FRelease) and Assigned(FUnregister);

    if Result then
      FRegister();

  end;

end;

// ...

procedure TExampleClass.DeInitMutexDLL();
begin

  if FHandleDLL <> INVALID_HANDLE_VALUE then
  begin
    FUnRegister();
    FreeLibrary(FHandleDLL);
  end;

end;

// ...

procedure TExampleClass.ExecuteMutex();
begin

  try
    FAcquire();
    // access INI-File
  finally
    FRelease();
  end;

end;

// ...

procedure TExampleClass.Execute();
begin
  InitMutexDLL();
  while not Terminated do
  begin
    ExecuteMutex();
    Sleep(100)
  end;
  DeInitMutexDLL();
end;
Tobias

Geändert von TheSledgeHammer (22. Mai 2019 um 14:24 Uhr)
  Mit Zitat antworten Zitat
peterbelow

Registriert seit: 12. Jan 2019
Ort: Hessen
263 Beiträge
 
Delphi 10.3 Rio
 
#6

AW: Mutex-Handling in DLL für zwei Programme

  Alt 22. Mai 2019, 15:39
Minimales Beispielprojekt zum Nachvollziehen?
Ich werde mal die Methoden hier rein schreiben, die notwendig wären, das wird so 1:1 nicht laufen.

Delphi-Quellcode:

TMyDllProc = procedure() of object; stdcall;
Die Deklaration ist falsch, die von der DLL exportierten Methoden sind nicht "of object"!
Mit deiner obigen Deklaration wird beim Aufruf ein zusätzlicher Parameter (Self) übergeben, den die DLL aber nicht erwartet. Das bringt den Call-Stack durcheinander.
Peter Below
  Mit Zitat antworten Zitat
TheSledgeHammer

Registriert seit: 22. Mai 2019
Ort: Mulfingen
5 Beiträge
 
Delphi 10.1 Berlin Enterprise
 
#7

AW: Mutex-Handling in DLL für zwei Programme

  Alt 23. Mai 2019, 06:44
Die Deklaration ist falsch, die von der DLL exportierten Methoden sind nicht "of object"!
Mit deiner obigen Deklaration wird beim Aufruf ein zusätzlicher Parameter (Self) übergeben, den die DLL aber nicht erwartet. Das bringt den Call-Stack durcheinander.
Ok, danke für den Hinweis. Tatsächlich sollte ich mir die Direktive "of object" mal noch genauer zu Gemüte führen, denn dass das automatisch zu einem "self"-Parameter führt, war mir jetzt nicht bewusst. Da bliebe jetzt noch die Frage offen, weshalb das zwar für DLL-Funktionen weg bleiben muss, bei Funktionen, die innerhalb des Delphi-Programms ausgetauscht werden, aber nicht weg bleiben darf?! Da kommt dann nachher nämlich der Compiler-Fehler "Inkompatible Typen: 'Reguläre Prozedur und Methodenzeiger'".

Im Konkreten Fall deklariere ich sowas hier:
Delphi-Quellcode:
TErrCallback = procedure(const AMsg: string) of object;
FCallbackOnError: TErrCallback;
und belege die Variable FCallbackOnError dann mit der Prozedur:
Delphi-Quellcode:
// Deklaration
procedure ShowErrorMessage(const AMsg: string);
// Definition
procedure TFormClass.ShowErrorMessage(const AMsg: string);
begin
  MessageDlg(AMsg, mtError, [mbOK], -1);
end;
Edit
Hab meine Frage glaub selbst beantwortet. Unten aufgeführter Link gibt da das entsprechende Stichwort:
Code:
Ein Methodenzeiger wird in Form zweier Zeiger codiert, von denen der erste die Adresse der Methode speichert, während der zweite eine Referenz auf das Objekt enthält, zu dem die Methode gehört.
http://docwiki.embarcadero.com/RADSt...zedurale_Typen
Tobias

Geändert von TheSledgeHammer (23. Mai 2019 um 06:55 Uhr)
  Mit Zitat antworten Zitat
hoika
Online

Registriert seit: 5. Jul 2006
Ort: Magdeburg
7.001 Beiträge
 
Delphi XE4 Professional
 
#8

AW: Mutex-Handling in DLL für zwei Programme

  Alt 23. Mai 2019, 07:12
Hallo,
sobald du eine Methode in einer Klasse hast, wird das Self beim Methodenaufruf immer mit übergeben.
Ist halt so.

Entweder deine Dll-Methoden (im Programm) sind nicht in einer Klasse,
oder du änderst die Prozeduren in der Dll -> neuer Parameter Dummy: TObject.
Heiko
  Mit Zitat antworten Zitat
Schokohase

Registriert seit: 17. Apr 2018
781 Beiträge
 
Delphi 10.2 Tokyo Starter
 
#9

AW: Mutex-Handling in DLL für zwei Programme

  Alt 23. Mai 2019, 08:25
Man kann sich viel Ärger ersparen, wenn man das erheblich einfacher umsetzt.

Hier mal die DLL
Delphi-Quellcode:
library TheMutex;

{ Wichtiger Hinweis zur DLL-Speicherverwaltung: ShareMem muss die erste
  Unit in der USES-Klausel Ihrer Bibliothek UND in der USES-Klausel Ihres Projekts
  (wählen Sie 'Projekt-Quelltext anzeigen') sein, wenn Ihre DLL Prozeduren oder Funktionen
  exportiert, die Strings als Parameter oder Funktionsergebnisse übergeben. Dies
  gilt für alle Strings, die an oder von Ihrer DLL übergeben werden, auch für solche,
  die in Records und Klassen verschachtelt sind. ShareMem ist die Interface-Unit zur
  gemeinsamen BORLNDMM.DLL-Speicherverwaltung, die zusammen mit Ihrer DLL
  weitergegeben werden muss. Übergeben Sie String-Informationen mit PChar- oder ShortString-Parametern, um die Verwendung von BORLNDMM.DLL zu vermeiden.
}


uses
  System.SysUtils,
  System.Classes,
  TheMutexImplementation in 'TheMutexImplementation.pas';

{$R *.res}

exports
  MutexAcquire,
  MutexRelease;

begin
end.
Delphi-Quellcode:
unit TheMutexImplementation;

interface

procedure MutexAcquire(); stdcall;
procedure MutexRelease(); stdcall;

implementation

uses
  System.SyncObjs,
  System.SysUtils;

var
  _Mutex: TMutex;

procedure MutexAcquire();
begin
  _Mutex.Acquire();
end;

procedure MutexRelease();
begin
  _Mutex.Release();
end;

initialization

_Mutex := TMutex.Create(nil, false, 'MyUniqueMutexName');

finalization

FreeAndNil(_Mutex);

end.
Und nun noch den benötigten Wrapper für die Dll
Delphi-Quellcode:
unit TheMutexWrapper;

interface

uses
  Winapi.Windows;

procedure MutexAcquire(); stdcall;
procedure MutexRelease(); stdcall;

const
  TheMutexDll = 'TheMutex.dll';

implementation

procedure MutexAcquire(); external TheMutexDll name 'MutexAcquire';
procedure MutexRelease(); external TheMutexDll name 'MutexRelease';

end.
  Mit Zitat antworten Zitat
TheSledgeHammer

Registriert seit: 22. Mai 2019
Ort: Mulfingen
5 Beiträge
 
Delphi 10.1 Berlin Enterprise
 
#10

AW: Mutex-Handling in DLL für zwei Programme

  Alt 23. Mai 2019, 08:37
Man kann sich viel Ärger ersparen, wenn man das erheblich einfacher umsetzt.
Sieh es mir bitte nach, aber DAS find ich beim besten Willen nicht einfacher Vielleicht "korrekter" aus programmiertechnischer Sicht, wenn es so etwas gibt. Ich mein, was hast du denn gemacht? Am Ende eine Unit erzeugt, die du mit initialization und finalization ausstatten konntest, sodass das Create und Free nicht in Funktionen gepackt werden muss. Wenn ich den Mutexnamen jetzt übergeben möchte, wird's allerdings schwierig und auch das Registrieren des Mutex kann ich nicht steuern damit. Und dynamisch laden wollt ich die DLL schon auch, also die "externals" wären an der Stelle für mich sowieso nicht gegangen; das kannst du aber natürlich nicht wissen, hatte ich auch nie erwähnt

Aber der Hinweis mit dem "of object" hat da tatsächlich geholfen, passt ja auch wunderbar zum Fehlerbild. Danke dafür, die jetzt anstehenden Tests werden es zeigen, aber sieht bisher ganz vielversprechend aus.

Entweder deine Dll-Methoden (im Programm) sind nicht in einer Klasse,
oder du änderst die Prozeduren in der Dll -> neuer Parameter Dummy: TObject.
Ja das mit dem Error-Callback war nicht in der DLL sondern das war ein Attribut einer anderen Klasse. Ich wollte damit auf den Unterschied zwischen DLL-Prozeduren und Klassen-Prozeduren hinaus, dass man beim ersteren kein "of object" verwenden darf und aber beim zweiten sogar verwenden muss. Der Grund ist mir wie gesagt ja jetzt klar
Tobias

Geändert von TheSledgeHammer (23. Mai 2019 um 08:44 Uhr)
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 11:55 Uhr.
Powered by vBulletin® Copyright ©2000 - 2019, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2019 by Daniel R. Wolf