Boost interruption dans l'implémentation d'invitation naïve

Question

J'ai développé un fil d'interrogation simple (en utilisant Boost 1.39.0) qui vérifie si une ressource de données a été accédée dans un laps de temps donné et efface la connexion sinon. Le code pertinent peut être revu ci-dessous.

Mes préoccupations sont de deux ordres:

1) utilise d'interruption sur un sommeil approprié pour fermer le fil en toute sécurité? L'interruption va-t-elle attendre que le sommeil se termine ou va-t-elle s'interrompre immédiatement? Vous pouvez voir que j'attrape une exception thread_interrupted juste pour échapper la boucle while.

2) Utilise-t-elle un fil qui passe le plus clair de son temps à gaspiller? Existe-t-il un meilleur modèle pour implémenter un mécanisme d'interrogation simple en C++ standard?

boost::xtime xt; 

while (1) { 
    try { 
     boost::xtime_get(&xt, boost::TIME_UTC); 
     xt.sec += _sleep_secs; 
     boost::thread::sleep(xt); 
     // 
     // logic to check resource access 
     // etc. 
    } 
    catch(boost::thread_interrupted const&) { 
     return; 
    } 
} 

Answer 1

1) Il doit être à l'abri de la mise en œuvre juger Boost de boost :: :: fil d'interruption() pour threads POSIX:

void thread::interrupt() 
{ 
    detail::thread_data_ptr const local_thread_info=get_thread_info(); 
    if(local_thread_info) 
    { 
     lock_guard<mutex> lk(local_thread_info->data_mutex); 
     local_thread_info->interrupt_requested=true; 
     if(local_thread_info->current_cond) 
     { 
      BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond)); 
     } 
    } 
} 

Ils verrouillent mutex, réglez interrupt_requested true et la diffusion sur une variable conditionnelle. Et le thread sera réveillé immédiatement s'il dort dans boost :: thread :: sleep(). Et ils n'utilisent pas pthread_cancel pour annuler un thread.

2) Je ne pense pas qu'un thread est un gaspillage de ressources si nous parlons de systèmes d'exploitation tels que Windows, Linux ou HP-UX. Ceci est une citation pour soutenir ce point:

De nombreux systèmes d'exploitation aussi ont des difficultés à gérer plus de quelques centaines de threads. Si chaque thread obtient un pile 2Mo (pas une valeur par défaut rare), de manquer de virtuel mémoire à (2^30/2^21) = 512 fils sur une machine de 32 bits avec 1 Go par l'utilisateur VM accessible (comme, par exemple, Linux normalement livré sur x86)

.

Answer 2

Je pense que l'utilisation est parfaitement bien, beaucoup de gens l'utilisent (pensez à la séquence d'arrêt, quand vous devez fermer des threads - vous interrompez() tout puis ils peuvent arrêter). En ce qui concerne boost, assurez-vous de lire la documentation: en particulier, seulement quelques instructions sont des "points d'interruption", ce qui signifie que le thread sera interrompu et n'obtiendra cette exception que si vous interrompez pendant que cette instruction est exécutée . Si le thread fait quelque chose d'autre, vous n'obtiendrez l'interruption que lorsque vous entrez un point d'interruption, ce qui peut prendre un certain temps après avoir demandé le interrupt, en fonction de ce que vous faites dans votre thread.

Je pense que c'est vrai dans tous les cas, voilà comment j'interprète les éléments suivants:

le fil sera interrompu la prochaine fois qu'il entre dans l'un des points d'interruption prédéfinis avec interruption activée, ou si elle est actuellement bloqué dans un appel à l'un des points d'interruption prédéfinis avec interruption activée.

de the boost thread documentation