Musings

Dans mon dernier poteau j'ai discuté l'utilisation de WaitForSingleObject par rapport aux mutexes et aux manières possibles de mettre en application la fonctionnalité équivalente en mettant en communication un tel code à GNU/Linux.  Dans ce poteau je décrirai l'utilisation de cet api avec des objets d'événement dans Microsoft Windows et proposerai des manières possibles de signaler un tel code à GNU/Linux ou à Unix.

D'abord, un certain fond sur des objets d'événement.  Un objet d'événement est juste un autre type d'objet d'expéditeur de grain de Windows.  D'un codage prespective, un objet d'événement est un objet de synchronisation qui encapsule un ou plusieurs objets d'expéditeur de grain et dont la sémantique de synchronisation sont accessible par l'intermédiaire de WaitForSingleObject et de ses cousins.  À un moment donné un objet de synchronisation nonsignaled ou est signalé, c.-à-d. l'objet peut seulement être dans un de deux états possibles.

Toute les famille de WaitFor des api comprenant l'attente de WaitForSingleobject sur une poignée d'objet ou les poignées jusqu'à quelques critères spécifiques est rencontrée.  Les deux critères de base pour tous ces api sont l'état signalé de l'objet sur lequel la poignée il attend et un valeur du dépassement de durée.  Ainsi un fil qui appelle des attentes de cet api jusqu'à ce que l'objet spécifique entre dans l'état signalé ou la temporisation spécifique a expiré.  Peu ou pas de temps- CPU est employé quand un tel fil est dans l'état d'attente.

Dans le cas des événements, un CreateEvent ou un OpenEvent renvoie une poignée à un objet d'événement.  Quand un événement est dans l'état signalé il signifie que cela l'événement a la capacité de libérer un ou plusieurs fils attendant cet événement particulier à signaler.  Quand un événement est dans l'état nonsignaled il ne libérera aucun fil de attente.  Au commencement l'état d'un événement nonsignaled.  Un état d'objet d'événement est placé explicitement à signaler par SetEvent ou PulseEvent.  Des objets d'événement sont également employés dans des opérations recouvertes telles que la lecture d'une douille, dans ce cas l'état d'objet d'événement est placé à signaler par le grain plutôt que par une application.

Les événements viennent également dans deux types remis à zéro.  Si un événement est un événement de manuel-remise, alors tout le retour de WaitForSingleObjects qui attendent cet événement si ainsi configuré.  En d'autres termes un événement de manuel-remise peut déclencher l'action par un ou plusieurs WaitForSingleObject ou ses cousins.  Un état d'objet d'événement de manuel-remise doit être remis à zéro explicitement à nonsignaled par ResetEvent.

Pour un objet d'événement de réinitialisation automatique, WaitForSingleObject et c'est des relations remis à zéro

Récemment j'ai été impliqué en mettant en communication une application à 32 bits qui a été au commencement écrite pour le NT de Microsoft Windows à GNU/Linux.  Cette application a contenu un grand nombre d'appels à NtWaitForSingleObject et un plus petit nombre d'appels à NtWaitForMultipleObject. 

Maintenant quiconque qui a dû mettre en communication le code contenant plus que quelques exemples de ces api Win32 particuliers, ou leurs cousins étroits WaitForSingleObjectEx, MsgWaitForMultipleObjects, MsgWaitForMultipleObjectsEx, etc. à Unix ou GNU/Linux probablement frissonne déjà avec le souvenir de longs jours et nuits laborieux du codage d'essai et des erreurs pour essayer et imiter correctement la sémantique et la fonctionnalité de ces api spécifiques particuliers de Microsoft Windows, mais pour le lecteur qui n'a pas encore dû essayer de mettre en communication une telle application, ce poteau et mon prochain poteau peut vous aider sauf votre santé d'esprit (et probablement vos cheveux !) autrefois à l'avenir.

D'ailleurs, tous les deux api sont marqués ont désapprouvé dans MSDN par Microsoft mais travaillent toujours comme prévus dans Windows NT et Windows Xp.  Je ne suis pas sûr au sujet de Windows Vista ou de Windows 7 car je ne les ai pas examinés sur ces logiciels d'exploitation.  Les deux api désapprouvés ont été remplacés par les api équivalents WaitForSingleObject et WaitForMultipleObject respectivement.  Pour le reste de ce poteau je discuterai juste les api de remplacement mais plus de ce que je dis soyez valide pour désapprouvée ou le remplacement api.

Au premier examen WaitForSingleObject semble assez bénin.  La description dans MSDN déclare que « cette fonction retourne quand l'objet spécifique est dans l'état signalé ou quand l'intervalle de temporisation s'écoule ».  Ressemble à d'un api assez simple et innofensif, droite ?  Peut-être quelque chose semblable au pthread_cond_timedwait de POSIX.1 api.  Bien, vous avez complètement tort et ce poteau et ce qui suit expliqueront pourquoi.

WaitForSingleObject et ses cousins peuvent attendre un signal du quelques un ou tout des « objets » suivants : changez l'avis, l'entrée de console, l'événement, le travail, l'avis de ressource de mémoire, le mutex, le processus, la sémaphore, le fil et le temporisateur waitable et dans des circonstances limitées sur les dossiers et l'entrée-sortie de dossier.  Une fois convenablement signalé, un fil est dégagé et continue.  Aucun api normalisé édité dans le monde de GNU/Linux ou d'Unix ne vient venu à manipuler cette gamme des objets dans un api simple.

C'est probablement l'un seul secteur où un Win32 api mieux est conçu que l'ensemble de GNU/Linux ou d'Unix api.  À GNU/Linux et à Unix il y a des api spécifiques pour attendre différentes sortes de