C# und C++ Synchronisieren zwischen Prozessen

Question

Wir haben 2 Anwendungen. Eine ist in C# geschrieben und die andere in C++. Wir müssen einen Zähler (im Speicher) verwalten, der von diesen Prozessen gemeinsam genutzt wird. Jedes Mal, wenn eine dieser Anwendungen startet, muss sie diesen Zähler überprüfen und erhöhen, und jedes Mal, wenn die Anwendung heruntergefahren wird, muss sie den Zähler verringern. Wenn die Anwendung abstürzt oder über den Task-Manager beendet wird, muss der Zähler ebenfalls verringert werden.
Wir dachten daran, eines der Synchronisationsobjekte des Betriebssystems wie MUTEX zu verwenden.
Meine Frage: Welche Art von Sync-Objekt ist die beste für Cross-Prozess (wenn eine C# und die andere C++ ist)

Ich hoffe, meine Frage war klar.
Ich danke Ihnen vielmals,

Adi Barda

Answer 1

Sie könnten mit dem Namen Semaphor durchkommen. Semaphore ist im Grunde eine Zählung, die es Entwicklern ermöglicht, die Anzahl der Threads/Prozesse, die auf eine Ressource zugreifen, zu begrenzen. Normalerweise funktioniert das so

1. Sie erstellen eine Semaphore mit der maximalen Anzahl N.
2. N Threads rufen eine Wartefunktion auf, WaitForSingleObject oder ähnliches und jeder von ihnen macht weiter, ohne zu warten. Jedes Mal geht der interne Semaphore-Zähler zurück.
3. N+1-Thread ruft ebenfalls die Wartefunktion auf, aber da der interne Zähler unserer Semaphore jetzt 0 ist, muss er warten.
4. Einer unserer ersten N Threads gibt die Semaphore durch den Aufruf ReleaseSemaphore Funktion. Diese Funktion inkrementiert den internen Zähler der Semaphore.
5. Unser wartender Thread muss jetzt nicht mehr warten, also wird er fortgesetzt, aber der Semaphorenzähler geht auf 0 zurück.

Ich glaube aber nicht, dass Sie es so verwenden wollen. Also, stattdessen sollten Sie:

1. Erzeugen einer benannten Semaphore mit einem auf Null gesetzten Anfangszähler.
2. Wenn die Anwendung beginnt, lassen Sie sie sofort los und erhöhen Sie den Zähler. Während dieses Aufrufs erhalten Sie den vorherigen Zählerstand.
3. Wenn die Anwendung endet, rufen Sie WaitForSingleObject(hSemaphore, 0) , wodurch der Zähler verringert wird. 0 bedeutet, dass Sie nicht warten wollen.

Das ist alles ganz einfach.

In C++

//create semaphore
HANDLER hSemaphore = CreateSemaphore(NULL, 0, BIG_NUMBER, "My cool semaphore name");
//increase counter
LONG prev_counter;
ReleaseSemaphore(hSemaphore, 1, &prev_counter);
//decrease counter
WaitForSingleObject(hSemaphore, 0);

In C#

using System.Threading;
//create semaphore
Semaphore sem = new Semaphore(0, BIG_NUMBER, "My cool semaphore name");
//increase counter
int prev_counter = sem.Release(); 
//decrease counter
sem.WaitOne(0);

Die Namen und BIG_NUMBERs sollten natürlich gleich sein.

Wenn dies für Ihre Aufgabe nicht ausreicht, müssen Sie sich mit gemeinsam genutztem Speicher befassen und den Zugriff darauf durch eine benannte Mutex sperren, aber das ist ein wenig komplizierter.

Answer 2

Es scheint, dass Sie eine benannte Semaphore (CreateSemaphore) benötigen: http://msdn.microsoft.com/en-us/library/ms682438(VS.85).aspx für C++, die sich für Inkrement/Dekrement eignet.

In C# haben Sie die Klasse System.Threading.Semaphore.

Answer 3

Werfen Sie einen Blick auf dieses Thema für Methoden, die einen Teil des Speichers zu Synchronisationszwecken gemeinsam nutzen oder aquí für einige Vorschläge zur Synchronisierung in .net/c#.

Wenn es .net-Methoden gibt, sollten sie sowohl für C++ als auch für C# funktionieren.