Multithread DLLs - gemeinsamer Speicher

[Delphi-Narr]

Hallo,
ich entwickle ein Programm, welches mehrere (ebenfalls selbst geschriebene) DLLs lädt, welche jeweils wiederkehrende Aufgaben erfüllen sollen, bis das Hauptprogramm sie
beendet.
Jede dieser DLLs hat die gleiche Struktur, d.h. einen vorgegebenen Aufrufsablauf an Funktionen.
Deshalb sollen diese DLLs über das "Hauptprogramm" in je einer Klasse erzeugt werden, die die eigentliche Kommunikation mit der DLL übernimmt.
Da die DLLs teilweise für Aufgaben etwas länger brauchen, die aber für alle anderen DLLs nicht von Belang sind, sollen die wiederkehrenden Aufgaben in Threads
ausgelagert sein.
Eine DLL besteht hierbei aus
1) Einer Init Funktion
2) Einer Tick Funktion (Diese soll wiederholt aufgerufen werden!)
3) Funktionen, welche vom Hauptprogramm aus ausgelöst werden, um bestimmte Events (Relevanter Tastendruck etc.) zu signalisieren.
4) Einer exit Funktion

Nun kann es vorkommen, dass eine DLL einen Wert in der Tick Methode benötigt, der durch eine andere DLL berechnet wurde.
Bisher habe ich dies (Single Thread) über eine Callback Methode gelöst, welche relevante Werte an das Hauptprogramm schickt,
welches diese in einer Liste abspeichert und bei Bedarf wieder ausliest. So konnten alle DLLs darauf zugreifen.

Nun meine eigentliche Frage(n):
Geht das einfacher? Können die DLLs (ohne sich untereinander zu kennen) auf Variablen anderer DLLs zugreifen?
Und der Hauptpunkt: Wenn die DLLs in Threads laufen sollen, macht es Sinn, die gesamte Klasse, welche die DLL verwaltet, in einen Thread zu packen, oder nur die einzige rechenintensive Funktion Tick?
Und wie kann ich vom Hauptprogramm immer noch Events an die Threads schicken und wie können die DLLs aus ihrem Thread heraus Werte zurück an die DLL übergreifende Speicherverwaltung schicken?
Erledigt dies alles ein Memory Manager, sodass ich theoretisch jeder DLL beim starten einen Pointer auf die Liste mit Werten geben kann und der gleichzeitige Zugriff auf diesen Wert dann vom Memory Manager (FastMM4 in meinem Fall) verhindert bzw. koordiniert wird?

Ich hoffe, das ist einigermaßen verständlich

Viele Grüße!

[Sir Rufo]

Sobald du vom gemeinsamen Zugriff auf Variablen in einer Multi-Thread-Umgebung sprichst, ist die Antwort pauschal immer "nicht threadsafe und fliegt dir irgendwann um die Ohren".

Ich kenne keinen Memory-Manager der Multi-Thread-Zugriffe auf den Speicher regelt.

Variablen sind niemals threadsafe. Nur Code kann threadsafe sein (oder eben nicht).

[Delphi-Narr]

Hm schade
Dann muss ich das also doch etwas "komplizierter" machen.
Bevor ich dann anfange: Wäre ein Aufbau wie im Anhang skizziert generell geeignet? (Das Synchronisieren des Puffers wird mit Synchronize ausgeführt).

Wenn ein Thread die Execute-Routine beendet hat, kann sie manuell erneut gestartet werden, ohne dass NICHT-Funktionsinterne Variablen, die im ersten Durchlauf verändert wurden, verloren gehen, oder? (Bin in Delphi noch nicht ganz drin in den Threads) Beispielsweise ein Objekt mit einer Datenbankverbindung kann wiederverwendet werden?

[Sir Rufo]

Du musst das nicht synchronisieren, sondern nur zuverlässig gewährleisten, dass ein gleichzeitiger Zugriff nicht erfolgen kann. (z.B. TCriticalSection)

Delphi-Quellcode:

unit Unit1;

interface

uses
  System.Classes,
  System.SyncObjs;

type
  TValueStore = class
  private
    FCS : TCriticalSection;
    FValues : TStringList;
    function GetValue( const Name : string ) : string;
    procedure SetValue( const Name, Value : string );
  public
    constructor Create;
    destructor Destroy; override;

    property Value[const Name : string] : string read GetValue write SetValue;
  end;

implementation

{ TValueStore }

constructor TValueStore.Create;
begin
  inherited;
  FCS := TCriticalSection.Create;
  FValues := TStringList.Create;
end;

destructor TValueStore.Destroy;
begin
  FValues.Free;
  FCS.Free;
  inherited;
end;

function TValueStore.GetValue( const Name : string ) : string;
begin
  FCS.Enter;
  try
    Result := FValues.Values[Name];
  finally
    FCS.Leave;
  end;
end;

procedure TValueStore.SetValue( const Name, Value : string );
begin
  FCS.Enter;
  try
    FValues.Values[Name] := Value;
  finally
    FCS.Leave;
  end;
end;

end.

Diese Klasse ist nun threadsafe, aber du musst auch aufpassen, dass der Zugriff auf die Instanz auch threadsafe ist und nicht von irgendwoher da wild neue Instanzen angelegt/freigegeben werden.

[Delphi-Narr]

Das sieht genau nach dem aus, was ich suche, danke!
Was meinst du denn mit dem letzten Satz genau, dass man nicht von irgendwoher neue Instanzen anlegen soll?!
Ich würde jetzt nach meinem Verständnis von dieser Klasse im Hauptthread eine Instanz erzeugen und den DLLs, welche in anderen Threads laufen, Pointer auf den Setter und Getter übergeben. Wäre das dann richtig oder ist das genau das, was es zu verhindern gilt?