C++-Multithreading-Framework (2): Mutex-Mutex und Sem-Semaphor

Gegenseitiger Ausschluss und Semaphore sind die beiden Grundlagen der Multi-Thread-Programmierung. Ich werde nicht näher auf ihre Prinzipien eingehen. Bitte lesen Sie das Betriebssystembuch oder schauen Sie online nach.

Für die Umsetzung des gegenseitigen Ausschlusses sind unabhängig vom Betriebssystem drei Schritte unabdingbar

Mutex-Sperre initialisieren

Vorgang sperren

Vorgang entsperren

Für verschiedene Systeme gibt es nur einige Unterschiede in den implementierten Funktionen, aber die Funktionen sind tatsächlich ähnlich. Während Sperrvorgängen und Entsperrvorgängen verfügen die meisten Systeme über einen Timeout-Mechanismus, um sicherzustellen, dass sie nicht immer gesperrt sind An dieser Stelle haben wir der Einfachheit halber kein Timeout festgelegt. Wenn wir die Sperre während des Sperrvorgangs nicht erhalten können, werden wir dort ewig warten.

Wir beschreiben die Basisklasse von Mutex wie folgt

class CMutex  
{  
    public:  
        CMutex(const char *pName = NULL);  //初始化锁  
        ~CMutex();  
        virtual bool Lock()=0;       //锁操作，纯虚函数  
        virtual bool UnLock()=0;  //解锁操作，纯虚函数  
        const char * getName(void) const {  
                return mutex_name;  
            }  
    protected:  
        char       *mutex_name;  //锁名字  
};

Für die Implementierung jedes Systems sind drei Initialisierungs-, Sperr- und Entsperrvorgänge erforderlich Teilweise sind diese drei Vorgänge unter Linux sehr einfach, daher werde ich den Code hier nicht veröffentlichen.

In ähnlicher Weise ist für das Semaphor Sem die Implementierung jedes Systems ähnlich, nichts weiter als

Initialisierung des Semaphors

Senden des Semaphors (Semaphor +1)

Semaphor empfangen (Semaphore-1)

Die Sem-Basisklasse wird wie folgt beschrieben

class CCountingSem  
{  
    public:  
        typedef enum {  
                 kTimeout,  
             kForever  
            }Mode;                      
        CCountingSem();     //初始化信号量  
        ~CCountingSem();  
         virtual bool Get() = 0;  //接收信号量  
             virtual bool  Post(void) = 0;   //发送信号量 
 };

Ebenso werde ich den Code für die spezifische Implementierung nicht veröffentlichen.

Für ein System, das das Entwurfsmuster erfüllt, können Sie diese Klassen beim Erstellen eines neuen Mutex und Semaphors natürlich nicht direkt neu erstellen, sondern müssen sie über a zurückgeben Einfaches Projekt, fügen Sie die Methoden newMutex und newCountingSem in der Klasse COperatingSystemFactory hinzu und geben Sie die entsprechenden Entitäten durch die Beurteilung des Betriebssystems durch COperatingSystemFactory zurück.

class COperatingSystemFactory  
{  
    public:  
        static COperatingSystem *newOperatingSystem();  
        static CCountingSem  *newCountingSem(unsigned int init=0); //参数是信号量的初始值，一般为0  
        static CMutex   *newMutex(const char *pName=NULL); 
 };

Okay, mit Mutex und Semaphor, wie benutzt man es? In der Hauptfunktion können wir zuerst die Mutex-Sperre und das Semaphor beantragen. Wenn wir anfangen Es gibt viele Threads, und wenn zwischen einigen von ihnen eine Mutex-Sperre erforderlich ist, weisen wir die angewendete Mutex-Sperre dem entsprechenden Thread zu und können sie dann direkt verwenden. Was jede Thread-Klasse betrifft, haben Sie sie einfach selbst geschrieben und von CThread geerbt. Es versteht sich von selbst, wie die darin enthaltenen Mitgliedsvariablen mit der in main beantragten Mutex-Sperre zusammenhängen. Sie können sie auch auf öffentliche Zuweisung setzen Nutzen Sie den Funktionsumfang von privat, alles bleibt Ihnen überlassen.

Mit der Mutex-Sperre und dem Semaphor kann die Nachrichtenwarteschlange gestartet werden. Mit der Nachrichtenwarteschlange ist das einfachste Multithreading-Modell abgeschlossen.

Github-Adresse:

https://github.com/wyh267/Cplusplus_Thread_Lib

Das Obige ist das C++-Multithreading-Framework (2) ：Mutex-Gegenseitigkeitsausschluss und Sem-Semaphor-Inhalte Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!