VC ++ 2010: erreur de section critique étrange

Le code retour “handle non valide spécifié” donne une image assez claire du fait que votre object de section critique a été désalloué; en supposant bien sûr qu’il a été alloué correctement pour commencer.

Votre classe RAII semble être un coupable probable. Si vous prenez du recul et que vous y réfléchissez, votre classe RAII viole le principe de Sepration Of Concerns , car elle a deux emplois:

1. Il fournit l’allocation / destruction de la sémantique pour CRITICAL_SECTION
2. Il fournit une sémantique d’acquisition / libération pour CRITICAL_SECTION

La plupart des implémentations d’un wrapper CS que j’ai vu violent le principe SoC de la même manière, mais cela peut être problématique. Surtout lorsque vous devez commencer à faire circuler des instances de la classe pour accéder à la fonctionnalité d’acquisition / libération. Considérons un exemple simple et inventé en psudocode:

 void WorkerThreadProc(CCriticalSection cs) { cs.Enter(); // MAGIC HAPPENS cs.Leave(); } int main() { CCriticalSection my_cs; std::vector stuff_used_by_multiple_threads; // Create 3 threads, passing the entry point "WorkerThreadProc" for( int i = 0; i < 3; ++i ) CreateThread(... &WorkerThreadProc, my_cs); // Join the 3 threads... wait(); } 

Le problème ici est que CCriticalSection est passé par valeur, donc le destructeur est appelé 4 fois. Chaque fois que le destructeur est appelé, le CRITICAL_SECTION est désalloué. La première fois marche bien, mais maintenant c'est parti.

Vous pouvez contourner ce problème en transmettant des références ou des pointeurs à la classe de la section critique, mais vous brouillez les eaux sémantiques avec les problèmes de propriété. Que se passe-t-il si le thread qui "possède" la critique meurt avant les autres threads? Vous pourriez utiliser un shared_ptr , mais maintenant, personne ne "possède" vraiment la section critique, et vous avez abandonné un peu de contrôle sur la zone afin de gagner un peu dans un autre domaine.

Le véritable "correctif" pour ce problème est de séparer les préoccupations. Avoir une classe pour l'allocation et la désallocation:

 class CCriticalSection : public CRITICAL_SECTION { public: CCriticalSection(){ InitializeCriticalSection(this); } ~CCriticalSection() { DestroyCriticalSection(this); } }; 

... et un autre pour gérer le locking et le délocking ...

 class CSLock { public: CSLock(CRITICAL_SECTION& cs) : cs_(cs) { EnterCriticalSection(&cs_); } ~CSLock() { LeaveCriticalSection(&cs_); } private: CRITICAL_SECTION& cs_; }; 

Vous pouvez maintenant passer des pointeurs bruts ou des références à un seul object CCriticalSection, éventuellement const, et faire en sorte que les threads de travail instancient leurs propres CSLocks. Le CSLock appartient au thread qui l'a créé, ce qui est le cas, mais la propriété de CCriticalSection est clairement conservée par un thread de contrôle; aussi une bonne chose.

• Assurez-vous que l’object Critical Section n’est pas dans #pragma packing 1 (ou un emballage autre que celui par défaut).
• Assurez-vous qu’aucun autre thread (ou même thread) ne corrompe l’object CS. Exécutez un outil d’parsing statique pour vérifier tout problème de saturation de la mémoire tampon.
• Si vous disposez d’un outil d’parsing d’exécution, exécutez-le pour trouver le problème.

J’ai décidé d’adhérer au principe KISS et rock and roll toute la nuit simplifier les choses. J’ai pensé que je remplacerais le CSharedMemoryClass avec un std::tr1::shared_ptr et un CCriticalSection qui le protège des access concurrents. Les deux sont membres du CImage maintenant, et les préoccupations sont mieux séparées maintenant, à CImage .

Cela a résolu la section critique étrange, mais maintenant, il semble que j’ai une fuite de mémoire causée par std::tr1::shared_ptr , vous pourriez me voir poster à ce sujet bientôt … Il ne se termine jamais!