guten abend,
ich frage mit hilfe einer DLL daten aus einem sensor ab. 500 mal pro sekunde. läuft wunderbar. wenn ich dann mit zwei threads zwei sensoren parallel abfrage kommt es anscheinend zu konflikten weil die sensoren dann verrückte werte zurückliefern. ich habe schon versucht nacheinander abzufragen, aber dann schaffe ich keine 500 werte pro sekunde die ich brauche. jetzt ist meine frage, ob ich eine DLL irgendwie zwei mal laden kann oder so damit jeder thread seine eigene abfragefunktion verwenden kann? das würde das problem imho lösen.
danke für lösungsvorschläge

Du solltest besser schauen auf welche Daten du nicht threadsicher zugreifst. Ohne zu wissen was du da wie machst (insbesondere das Datenhandling) wird dir dabei aber kaum jemand viel helfen können.

Entscheidend ist z.B., dass du keine globalen Variablen (sind ja eh böse) oder ähnliches benutzt, denn das führt durch die parallelen Zugriffe zu genau solchen Problemen.

also da sollte das problem eigentlich nicht liegen..

markieren

Code:

procedure tsensorthread.daten_aufnehmen();
begin
  while self.messen do begin
    self.erg:=s_getvalues(self.id,self.werte); //DLL Funktion
    if self.erg>0 then begin
      ...
    end;
    ...
  end;
end;

es wird die sensor id übergeben und in dem array "werte" habe ich danach die daten. und wenn die funktion parallel aufgerufen wird steht da in beiden arrays jeweils ein mix aus beiden sensordaten drin. das kann ich bei debuggen anhand der daten schließen.

Du hast aber schon für beide Sensoren ein Array und die sind nicht global?

Ist eine DLL geladen, dann ist diese geladen und wird nicht noch einmal in den Speicher geholt.
Ist diese DLL nicht threadsafe, dann kann man nicht mit mehr als einem Thread darauf zugreifen.

Innerhalb der eigenen Anwendung muss man logischerweise natürlich auch auf threadsafe achten - aber das haben meine Vorredner ja schon angeführt.

Wenn eine DLL nuch doch n-mal geladen werden soll, dann muss diese DLL auch n-mal auf der Platte vorhanden sein, damit Windows sich denkt, oh die ist anders, darum muss ich die jetzt doch laden

ja das sollte sicher sein..

markieren

Code:

type
  tsensorthread = class(tthread)
    private
      id: integer;
      werte: valArr;
      ...
  end;
...
var
  sensoren: array [1..2] of tsensorthread;
...

gibs denn vielleicht die möglichkeit die DLL zu kopieren, also zb sensor1.dll und sensor2.dll zu haben, und dann sowas wie:

markieren

Code:

function s_getvalues(id: longword; values: valArr):longword; cdecl; external 'sensor1.dll';
function s_getvalues(id: longword; values: valArr):longword; cdecl; external 'sensor2.dll';

aber dann gibs ja halt einen funktionsnamen konflikt. also irgendwie sowas in der art

Was ist valArr?

markieren

Delphi-Quellcode:

function getvalues1(id: longword; values: valArr):longword; cdecl; external 'sensor1.dll' name 's_getvalues';
function getvalues2(id: longword; values: valArr):longword; cdecl; external 'sensor2.dll' name 's_getvalues';

Ist dir noch nie aufgefallen, daß der Name in deinem Quellcode mit dem Exportnamen der DLL nicht viel zu tun hat?

Beispiel:

markieren

Delphi-Quellcode:

function CreateFile; external kernel32 name 'CreateFileW'; // bis D2007 CreateFileA
function CreateFileA; external kernel32 name 'CreateFileA';
function CreateFileW; external kernel32 name 'CreateFileW';

Das Problem liegt wohl eher in der DLL. Da werden dann gerne Initialisierungen (hier z.B. der Sensoren) global gemacht oder so.

Wie sieht denn der Quelltext dort grob aus?

Für so einen Ansatz würde ich empfehlen eine Klasse zu erstellen, die das Kopieren der DLL vornimmt (z.B. in den Temp-Ordner) und die DLL dynamisch lädt.

Wird die Instanz dann ins Nirwana geschickt, dann kann auch die DLL aus dem Temp Ordner gelöscht werden. Um ganz sicher zu gehen, dass die Kopie immer gelöscht wird, kann man. auch noch mit einem speziellen Copy-Befehl dafür sorgen, dass die Datei sich automatisch nach Prozessende von selber löscht.

Resultat:

Der Zugriff auf die DLL Funktionen ist so einfach wie das Benutzen einer Klasse
Die zusätzlichen Daten liegen innerhalb der Klasseninstanz und können dort threadsafe bereitgestellt werden
Bei der Auslieferung des Programms nur eine DLL-Datei und dadurch kein Versionsmischmasch möglich
Weitere Threads problemlos möglich

Das halte ich für den falschen Ansatz. Leg die DLL so aus, dass sie threadsafe ist. Zwei mal laden geht in die Hose. Spätestens wenn ein zweiter Progranmmierer sie verwendet und nichts davon weiß. Auch wenn du dir das jetzt nicht vorstellen kannst. Aber glaub mir, in einem halben Jahr bist du der zweite Programmierer.