Framework multi-thread C (1) : nouveau démarre un thread à la fois

J'ai écrit un framework multi-thread C il y a quelques années. Même s'il était terminé, j'étais trop paresseux pour l'expliquer une fois, puis j'ai récemment trié le code et je me suis préparé à l'envoyer à github. allons Résumons ce cadre.

Le multithreading a toujours été un problème courant en programmation, en particulier sous Linux C, le multithreading n'a pas été bien encapsulé. Bien sûr, il existe de nombreux tiers. des bibliothèques qui peuvent Il peut être utilisé, comme boost, mais parfois nous n'avons pas besoin d'une bibliothèque aussi énorme et avons juste besoin d'un framework de threads léger, j'en ai donc compilé un moi-même. Il n'est actuellement utilisé que sous Linux, mais lors de sa conception, il l'est. compilé selon plusieurs plates-formes. Si vous en avez besoin, vous pouvez ajouter vous-même quelques classes et en faire une plate-forme Windows pour d'autres plates-formes, telles que eCos, Vxworks, etc. .

Pour le multithreading, ce dont nous avons besoin est d'encapsuler la couche inférieure du système d'exploitation afin que les utilisateurs puissent prêter plus d'attention à sa logique de code lors de l'écriture de programmes plutôt qu'à la différences entre les threads. Pour la logique, il est préférable de démarrer un thread après avoir créé une nouvelle classe. La communication entre les threads est également encapsulée par la classe correspondante, et il suffit de l'appeler.

Sur cette base, nous avons défini un ensemble de classes de base pour encapsuler diverses interfaces multithread

opérations Système classe de base, qui définit principalement la fonction createThread pour créer des threads. Cette fonction est une fonction virtuelle pure. Les classes qui en sont héritées doivent implémenter leurs fonctions en fonction de la plateforme

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

<.>

La classe de base du thread définit threadEntry comme entrée du thread, initializeThread pour initialiser le thread, et les sous-classes peuvent initialiser différentes variables membres. mainLoop est une fonction virtuelle pure, qui est la fonction principale. du thread. Généralement, il s'agit d'une boucle while et les sous-classes doivent implémenter cette fonction virtuelle.

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

Afin d'être indépendant de la plate-forme, un modèle d'usine simple est utilisé pour renvoyer différentes classes de système d'exploitation, classes de sémaphore et classes de mutex selon différentes plates-formes.

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

Classe de base de sémaphore, la fonction virtuelle pure définit les méthodes get et post sémaphore, les sous-classes doivent implémenter différentes implémentations selon le type de système

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

Classe de base mutuellement exclusive, la fonction virtuelle pure définit deux méthodes de verrouillage et de déverrouillage. De même, les sous-classes doivent implémenter différentes implémentations selon le type de système

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

L'autre chose importante est la classe msgQueue, dont je parlerai la prochaine fois.

Avec ces cours de base, nous pouvons commencer.

Le résultat que nous espérons est que

L'utilisateur, c'est-à-dire le programmeur, hérite d'un fil de son Je possède la classe CThread, telle que CTestThread, puis implémente la méthode mainLoop de cette façon, un thread qui ne prend pas en compte la communication est terminé. Il me suffit ensuite de recréer le CTestThread dans main.cpp, puis le thread sera démarré. sans aucune autre opération fastidieuse.

Pour réaliser une telle fonction, quels types d'appels combinés sont nécessaires pour les classes ci-dessus ?

Tout d'abord, parce que c'est sous Linux, toutes les classes de base doivent dériver les sous-classes correspondantes pour Linux (CThread n'en a pas besoin car il est écrit par l'utilisateur, et COperatingSystemFactory (non également, car il s'agit d'une usine abstraite), nous avons donc créé trois sous-classes de CLinuxMutex, CLinuxOperratingSystem et CLinuxCountingSem sous Linux, et implémenté les fonctions virtuelles pures de la classe de base dans ces sous-classes.

Ensuite, après avoir créé un nouveau CTestThread, nous devons générer un CLinuxOperratingSystem via le newOperatingSystem de COperatingSystemFactory, puis CLinuxOperratingSystem appelle createThread pour générer une fonction de thread, puis se lie la mainLoop de CTestThread à ceci dans la fonction thread.

Oui, c'est aussi simple que cela

Après avoir téléchargé tous les fichiers dans github, il vous suffit d'écrire votre Votre propre classe de fil de discussion, telle que :

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

Ensuite, dans main.cpp, appelez une nouvelle phrase à cette classe :

OK , tout est fait, maintenant lancez-le, vous pouvez continuer à taper hello world.

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

De même, vous pouvez également créer plusieurs instances

Si vous souhaitez des threads avec d'autres fonctions, vous pouvez simplement dériver une autre classe de CThread. C'est très simple.

La chose un peu plus compliquée est la communication par fil de discussion, qui sera abordée la prochaine fois.

Le code n'a pas encore été trié. Une fois trié et téléchargé sur github, cela prendra probablement encore deux ou trois jours.

adresse github :

https://github.com/wyh267/Cplusplus_Thread_Lib

Ce qui précède est le framework multi-threading C (1) ：new démarre le contenu d'un fil à la fois. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !