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; 
 };

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.

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.

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 (m.sbmmt.com)!