Threading dans une DLL où la DLL doit retourner avant la fin du thread enfant

Question

Je travaille sur l'écriture d'une DLL wrapper pour interfacer une DLL de communication pour un wattmètre yokogawa WT1600, vers un package d'automatisation basé sur PC. J'ai réussi à faire fonctionner la partie communication, mais j'ai besoin de l'enfiler pour pouvoir conserver une durée de balayage de 50 ms du paquet d'automatisation. (L'appel EFB (Extended Function Block) bloquera le balayage jusqu'à ce qu'il revienne)

Voici les étapes à suivre.

1. Appel EFB
2. EFB crée un thread pour effectuer la configuration de la communication (prend environ 200ms à faire)
3. EFB retourne EFB_BUSY alors que le thread effectue le travail
   • 3a. (Programme d'automatisation continue la numérisation jusqu'à ce qu'il revienne à l'appel EFB)
4. Appel EFB en passant qu'il est revenu occupé le dernier appel
5. vérifie EFB si le fil est de retour
6. Si le fil est revenu ensuite l'EFB retourne le succès, le retour Else EFB_BUSY
7. répétition 3a-6 jusqu'au retour EFB succès

donc mon problème est, comment puis-je créer un fil qui existe après la vie de la fonction qui l'a appelé? Et comment puis-je obtenir cette valeur de retour de thread lorsque je rappelle dans la DLL?

EDIT # 1

 HeavyFunction::HeavyFunction^ hf; //HeavyFunction is a class that has a time consuming function in it 
     ThreadStart^ efbThreadDelegate; 
     Thread^ efbThread; 

     if(pEfbData->nBlockingRecall != DOEFB_BUSY) { 
      hf = gcnew HeavyFunction::HeavyFunction; 
      hf->iiStart = (int)(pEfbData->uParams[0].dw); 
      hf->iiEnd = (int)(pEfbData->uParams[1].dw); 
      efbThreadDelegate = gcnew ThreadStart(hf, &HeavyFunction::HeavyFunction::iGetPrime); 
      efbThread = gcnew Thread(efbThreadDelegate); 
      efbThread->Start(); 
      return DOEFB_BUSY; 
     }else if (efbThread->IsAlive) { 
      return DOEFB_BUSY; 
     }else { 
      uRetValue->dw = hf->iReturn; 
      return 0; 
     } 

Will efbThread ont toujours la même poignée de fil lors d'un appel ultérieur?

EDIT # 2

Je l'ai eu à travailler en créant une poignée globale pour un Mutex et un fil. Initialisation du mutex dans le point d'entrée init (effectué lors du chargement de dll) et création du thread dans la fonction principale lorsqu'un appel est réellement effectué vers la dll.

J'ai utilisé l'exemple de code de MSDN: Creating Threads comme modèle.

Answer 1

Tout thread créé (que ce soit dans une DLL ou ailleurs) ne s'arrêtera pas spontanément. En particulier, la fonction qui a créé le thread peut retourner. Le nouveau thread continuerait à fonctionner même si le thread créateur était terminé. Autrement dit, en supposant qu'il n'a pas atteint la fin de sa fonction d'entrée.

Les threads Windows retournent un DWORD lorsqu'ils sont prêts. Pour jeter un coup d'œil, appelez WaitForSingleObject sur le handle de thread avec un délai d'expiration de 0 seconde et, si cela réussit, appelez GetExitCodeThread.

Je ne comprends pas tout votre "EFB", ni ce qu'il est ni ce qu'il fait, cependant. Si cela fait des choses drôles aux threads Windows normaux, tous les paris sont désactivés.