C++-Multithreading-Framework (1): new startet einen Thread sofort

Vor ein paar Jahren habe ich ein C++-Multithread-Framework geschrieben, aber ich war zu faul, es einmal zu erklären, und habe dann den Code aussortiert und mich darauf vorbereitet, ihn hier zu veröffentlichen Lassen Sie uns diesen Rahmen zusammenfassen.

Multithreading war schon immer ein häufiges Problem in der Programmierung, insbesondere in C++ unter Linux. Natürlich gibt es viele Drittanbieter. Party-Bibliotheken, die verwendet werden können, wie zum Beispiel Boost, aber manchmal brauchen wir keine so große Bibliothek und brauchen nur ein leichtes Thread-Framework, also habe ich selbst eines kompiliert. Es wird derzeit nur unter Linux verwendet, aber beim Entwerfen wird nach mehreren Plattformen kompiliert. Bei Bedarf können Sie einige Klassen selbst hinzufügen und daraus eine Windows-Plattform für andere Plattformen wie eCos, Vxworks usw. machen. .

Für Multithreading müssen wir die unterste Ebene des Betriebssystems kapseln, damit Benutzer beim Schreiben von Programmen mehr auf seine Codelogik achten können als auf die Unterschiede zwischen Threads: Aus logischen Gründen ist es am besten, einen Thread nach dem Erstellen einer neuen Klasse zu starten. Die Kommunikation zwischen Threads wird ebenfalls von der entsprechenden Klasse gekapselt und muss nur aufgerufen werden.

Auf dieser Grundlage haben wir eine Reihe von Basisklassen definiert, um verschiedene Multithread-Schnittstellen

Operationssystem zu kapseln Basisklasse, die hauptsächlich die Funktion createThread zum Erstellen von Threads definiert. Diese Funktion ist eine rein virtuelle Funktion, die von ihr geerbt werden muss, um ihre Funktionen entsprechend der Plattform zu implementieren 🎜 >

class COperatingSystem 
 {  
    public:  
        COperatingSystem();  
        ~COperatingSystem();  
  
        virtual  bool createThread(CThread *mThread,unsigned long stack_size=8*1024)=0;  
        virtual void  sleepSec(unsigned long sec)=0;  
  
    protected:  
        CThread     *p_thread; 
 };

Die Thread-Basisklasse definiert threadEntry als Eingang zum Thread, initializeThread zum Initialisieren des Threads und Unterklassen können verschiedene Mitgliedsvariablen initialisieren. mainLoop ist eine rein virtuelle Funktion, die die Hauptfunktion darstellt Im Allgemeinen handelt es sich um eine While-Schleife, und Unterklassen müssen diese virtuelle Funktion implementieren.

Um plattformunabhängig zu sein, wird ein einfaches Fabrikmuster verwendet, um je nach Plattform unterschiedliche Betriebssystemklassen, Semaphorklassen und Mutexklassen zurückzugeben.

class CThread  
{  
    public:  
        CThread(const char *m_thread_name);  
        ~CThread();  
         void threadEntry(CCountingSem *pSemaphore);  
  
    protected:  
        virtual bool initializeThread();  
        virtual void mainLoop()=0;  
  
        COperatingSystem        *p_opration_system;  
        char        *p_thread_name;  
};

Semaphor-Basisklasse, reine virtuelle Funktion definiert Get- und Post-Semaphor-Methoden, Unterklassen müssen je nach Systemtyp unterschiedliche Implementierungen implementieren

class COperatingSystemFactory  
{  
    public:  
        static COperatingSystem *newOperatingSystem();  
        static CCountingSem  *newCountingSem(unsigned int init);  
        static CMutex           *newMutex(const char *pName=NULL);  
};

Sich gegenseitig ausschließende Basisklasse, reine virtuelle Funktion definiert zwei Methoden zum Sperren und Entsperren. Ebenso müssen Unterklassen je nach Systemtyp unterschiedliche Implementierungen implementieren

class CCountingSem  
{  
    public:  
        CCountingSem();  
        ~CCountingSem();  
         virtual bool                Get(Mode mode = kForever, unsigned long timeoutMS = 0) = 0;  
             virtual bool                Post(void) = 0; 
 };

Das andere wichtige Ding ist die msgQueue-Klasse, über die ich beim nächsten Mal sprechen werde.

class CMutex  
{  
    public:  
        CMutex(const char *pName = NULL);  
        ~CMutex();  
        virtual bool Lock()=0;  
        virtual bool UnLock()=0;  
  
    protected:  
        char       *mutex_name; 
 };

Mit diesen Grundkursen kann es losgehen.

Das Ergebnis, das wir hoffen, ist, dass

Der Benutzer, also der Programmierer, einen Thread von ihm erbt Eigene CThread-Klasse, z. B. CTestThread, und dann die mainLoop-Methode implementieren. Auf diese Weise wird ein Thread abgeschlossen, der die Kommunikation nicht berücksichtigt. Dann muss ich nur den CTestThread in main.cpp neu erstellen, und dann wird der Thread gestartet ohne weitere umständliche Vorgänge.

Um eine solche Funktion zu erreichen, welche Art von kombinierten Aufrufen sind für die oben genannten Klassen erforderlich?

Da es unter Linux läuft, müssen zunächst alle Basisklassen die entsprechenden Unterklassen für Linux ableiten (CThread benötigt es nicht, da es vom Benutzer geschrieben wird, und (COperatingSystemFactory auch Nein, da es sich um eine abstrakte Fabrik handelt). Daher haben wir unter Linux drei Unterklassen von CLinuxMutex, CLinuxOperratingSystem und CLinuxCountingSem erstellt und in diesen Unterklassen die rein virtuellen Funktionen in der Basisklasse implementiert.

Als nächstes müssen wir, nachdem wir einen neuen CTestThread erstellt haben, ein CLinuxOperratingSystem über das newOperatingSystem von COperatingSystemFactory generieren. Anschließend ruft CLinuxOperratingSystem createThread auf, um eine Thread-Funktion zu generieren, und bindet dann die mainLoop von CTestThread zu dieser In-Thread-Funktion.

Ja, so einfach ist das

Nachdem Sie alle Dateien in Github heruntergeladen haben, müssen Sie nur noch Ihre Datei schreiben eigene Thread-Klasse, wie zum Beispiel:

Rufen Sie dann in main.cpp einen neuen Satz zu dieser Klasse auf:

class TestThread:public CThread  
{  
    public:  
        TestThread(const char *m_name);  
        ~TestThread();  
        virtual void mainLoop();  
};  
//然后实现mainLoop方法：  
void TestThread::mainLoop()  
{  
    while(1)  
        {  
            printf("%s :hello world\n",p_thread_name);  
              
        }  
}

OK , Alles ist erledigt, jetzt führen Sie es aus, Sie können mit der Eingabe von „Hallo Welt“ fortfahren.

Ebenso können Sie auch mehrere Instanzen neu erstellen.

Wenn Sie Threads mit anderen Funktionen wünschen, können Sie einfach eine andere Klasse von CThread ableiten. Das ist sehr einfach.

TestThread *a=new TestThread("Thread A");

Die etwas kompliziertere Sache ist die Thread-Kommunikation, über die ich beim nächsten Mal sprechen werde.

Der Code wurde noch nicht aussortiert. Sobald er aussortiert und auf Github hochgeladen ist, wird es wahrscheinlich noch zwei oder drei Tage dauern.

Github-Adresse:

https://github.com/wyh267/Cplusplus_Thread_Lib

Das Obige ist das C++-Multithreading-Framework (1) ：Neu startet den Inhalt eines Threads sofort. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!