Kann jemand Mutex erklären und wie es benutzt wird?

Question

Ich lese ein paar Dokumente über Mutex und immer noch die einzige Idee, die ich habe, ist, dass es verhindert, dass Threads auf eine Ressource zugreifen, die bereits von einer anderen Ressource verwendet wird.

Ich habe von Code-Schnipsel und ausgeführt, die funktioniert:

#include <windows.h> 
#include <process.h> 
#include <iostream> 
using namespace std; 


BOOL FunctionToWriteToDatabase(HANDLE hMutex) 
{ 
    DWORD dwWaitResult; 
    // Request ownership of mutex. 
    dwWaitResult = WaitForSingleObject(
    hMutex, // handle to mutex 
    5000L); // five-second time-out interval 
     switch (dwWaitResult) 
     { 
     // The thread got mutex ownership. 
      case WAIT_OBJECT_0: 
      __try 
      { 
       // Write to the database. 
      } 
      __finally { 
      // Release ownership of the mutex object. 
      if (! ReleaseMutex(hMutex)) { 
      // Deal with error. 
     } 
      break; 
     } 
      // Cannot get mutex ownership due to time-out. 
      case WAIT_TIMEOUT: 
      return FALSE; 
      // Got ownership of the abandoned mutex object. 
      case WAIT_ABANDONED: 
      return FALSE; 
     } 
    return TRUE; 
} 

void main() 
{ 
    HANDLE hMutex; 

    hMutex=CreateMutex(NULL,FALSE,"MutexExample"); 

    if (hMutex == NULL) 
    { 
     printf("CreateMutex error: %d\n", GetLastError()); 
    } 
    else if (GetLastError() == ERROR_ALREADY_EXISTS) 
     printf("CreateMutex opened existing mutex\n"); 

    else 
     printf("CreateMutex created new mutex\n"); 

} 

Aber was ich nicht verstehe, ist, wo ist der rote Faden und wo ist die gemeinsam genutzte Ressource? Kann jemand bitte einen besseren Artikel oder ein besseres Dokument erklären oder bereitstellen?

Answer 1

Ein Mutex bietet mut ually ex clusive Zugriff auf eine Ressource; In Ihrem Fall eine Datenbank. Es gibt nicht mehrere Threads in Ihrem Programm, aber Sie können mehrere Instanzen Ihres Programms ausführen, gegen die Ihr Mutex schützt. Effektiv schützt es immer noch vor dem Zugriff von mehr als einem Thread, nur dass diese Threads in separaten Prozessen sein können.

Ihr Code erstellt einen mit dem Namen Mutex, der für mehrere Instanzen Ihrer Anwendung freigegeben werden kann. Dies ist eine Form der Interprozesskommunikation. MSDN-Dokumentation auf CreateMutex hat weitere hilfreiche Informationen über Namen mutexes:

Zwei oder mehr Prozesse CreateMutex nennen können den gleichen Namen Mutex zu erstellen. Der erste Prozess tatsächlich schafft den Mutex und nachfolgende Prozesse mit ausreichendem Zugang Rechte einfach einen Griff öffnen, um die bestehenden Mutex ...

Mehr Prozesse Griffe von das gleichen Mutex-Objekt haben können, was die Verwendung von das Objekt für Interprozess Synchronisation.

Ein Mutex ist hier nur notwendig, wenn die Datenbank, die Sie gegen arbeiten von Natur aus nicht multithreaded Zugriff unterstützen.

Answer 2

Vielleicht die beste Quelle für Sie Es wird

sein

http://en.wikipedia.org/wiki/Mutual_exclusion

Answer 3

Sie dies zum Vergleich der verschiedenen Fadensynchronisationsmechanismen SO Post beziehen Difference between Locks, Mutex and Critical Sections

Wenn Sie spezifische Informationen Mutex wollen, dann wird wikipedia gib dir genug Details.

Answer 4

Diese link in msdn bietet ein ähnliches Beispiel wie Sie mit Threads in der main() -Funktion gemacht. Aber wieder ist die freigegebene Ressource, die eine Datenbank sein soll, nicht enthalten.
Wie dem auch sei, eine gemeinsame Ressource ist, was auch immer, die von mehreren Threads zugegriffen werden muss: settingsfiles, Treiber, Datenbank, ...

Wohlgemerkt, dass der Zähler im Beispiel geschrieben wird, während durch die Mutex geschützt, während es wurde gelesen, während nicht geschützt wird. Während es in diesem Fall wahrscheinlich kein Problem gibt, ist es ein wenig schlampig.