je travaille actuellement une petite applicatino multi-threadée (2
threads). Mon problème est que pour termiber l'exécution, j'intercepte
les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon
application part en dead lock quand je tape Ctrl+C, et je pense que
c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Ma question est donc: quel est le moyen canonique d'intercepter les
Ctrl+C pour terminer proprement l'execution d'une application multi
threadée?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Grasshoper
09/10/2008 13:54 - Guillaume GOURDIN :
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est de dédier un thread à l'interception des signaux, et de les attendre gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les autres threads.
09/10/2008 13:54 - Guillaume GOURDIN :
je travaille actuellement une petite applicatino multi-threadée (2
threads). Mon problème est que pour termiber l'exécution, j'intercepte
les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon
application part en dead lock quand je tape Ctrl+C, et je pense que
c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Ma question est donc: quel est le moyen canonique d'intercepter les
Ctrl+C pour terminer proprement l'execution d'une application multi
threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est
de dédier un thread à l'interception des signaux, et de les attendre
gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les
autres threads.
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est de dédier un thread à l'interception des signaux, et de les attendre gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les autres threads.
Guillaume GOURDIN
>> Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est de dédier un thread à l'interception des signaux, et de les attendre gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les autres threads.
Merci pour l'information. Quelle est la fonction à appeler pour bloquer les signaux dans un thread?
Merci encore.
>> Ma question est donc: quel est le moyen canonique d'intercepter les
Ctrl+C pour terminer proprement l'execution d'une application multi
threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est
de dédier un thread à l'interception des signaux, et de les attendre
gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les
autres threads.
Merci pour l'information. Quelle est la fonction à appeler pour bloquer
les signaux dans un thread?
>> Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est de dédier un thread à l'interception des signaux, et de les attendre gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les autres threads.
Merci pour l'information. Quelle est la fonction à appeler pour bloquer les signaux dans un thread?
Merci encore.
Jean-Marc Bourguet
Guillaume GOURDIN writes:
Bonjour à tous,
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Merci beaucoup pour votre aide.
Bloquer les signaux asynchrones dans toutes les threads sauf une qui est bloquee en attente de ceux-ci. Voir sigwait et pthread_sigmask.
Chercher eventuellement dans les archives de comp.programming.threads avec ces mots cles les messages de David Butenhof.
je travaille actuellement une petite applicatino multi-threadée (2
threads). Mon problème est que pour termiber l'exécution, j'intercepte les
SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application
part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait
que la fonction 'signal' n'est pas thread safe.
Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C
pour terminer proprement l'execution d'une application multi threadée?
Merci beaucoup pour votre aide.
Bloquer les signaux asynchrones dans toutes les threads sauf une qui est
bloquee en attente de ceux-ci. Voir sigwait et pthread_sigmask.
Chercher eventuellement dans les archives de comp.programming.threads
avec ces mots cles les messages de David Butenhof.
A+
--
Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de
usenet-fr: http://www.usenet-fr.news.eu.org
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Merci beaucoup pour votre aide.
Bloquer les signaux asynchrones dans toutes les threads sauf une qui est bloquee en attente de ceux-ci. Voir sigwait et pthread_sigmask.
Chercher eventuellement dans les archives de comp.programming.threads avec ces mots cles les messages de David Butenhof.
Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est de dédier un thread à l'interception des signaux, et de les attendre gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les autres threads.
Merci pour l'information. Quelle est la fonction à appeler pour bloquer les signaux dans un thread?
pthread_sigmask()
Une bonne référence sur ce sujet : Programmation système en C sous Linux, Christophe Blaess, chapitre 12.
09/10/2008 14:24 - Guillaume GOURDIN :
Ma question est donc: quel est le moyen canonique d'intercepter les
Ctrl+C pour terminer proprement l'execution d'une application multi
threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est
de dédier un thread à l'interception des signaux, et de les attendre
gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les
autres threads.
Merci pour l'information. Quelle est la fonction à appeler pour bloquer
les signaux dans un thread?
pthread_sigmask()
Une bonne référence sur ce sujet : Programmation système en C sous
Linux, Christophe Blaess, chapitre 12.
Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Une des méthodes (il y en a peut-être d'autre que je ne connais pas) est de dédier un thread à l'interception des signaux, et de les attendre gentiment avec sigwaitinfo() (dans une belle boucle while(1)).
Ce qui implique que les signaux doivent être bloqués dans tous les autres threads.
Merci pour l'information. Quelle est la fonction à appeler pour bloquer les signaux dans un thread?
pthread_sigmask()
Une bonne référence sur ce sujet : Programmation système en C sous Linux, Christophe Blaess, chapitre 12.
Guillaume GOURDIN
>> Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Bloquer les signaux asynchrones dans toutes les threads sauf une qui est bloquee en attente de ceux-ci. Voir sigwait et pthread_sigmask.
Ok, j'ai fait comme recommandé par vous 2: j'ai un thread qui ne sert qu'à intercepter les signaux grâce à sigwait. Ma question est la suivante: l'appel à sigwait étant bloquant, est-il gênant de ne pas terminer ce thread proprement lorsque le programme se termine naturellement?
>> Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C
pour terminer proprement l'execution d'une application multi threadée?
Bloquer les signaux asynchrones dans toutes les threads sauf une qui est
bloquee en attente de ceux-ci. Voir sigwait et pthread_sigmask.
Ok, j'ai fait comme recommandé par vous 2: j'ai un thread qui ne sert
qu'à intercepter les signaux grâce à sigwait. Ma question est la
suivante: l'appel à sigwait étant bloquant, est-il gênant de ne pas
terminer ce thread proprement lorsque le programme se termine naturellement?
>> Ma question est donc: quel est le moyen canonique d'intercepter les Ctrl+C pour terminer proprement l'execution d'une application multi threadée?
Bloquer les signaux asynchrones dans toutes les threads sauf une qui est bloquee en attente de ceux-ci. Voir sigwait et pthread_sigmask.
Ok, j'ai fait comme recommandé par vous 2: j'ai un thread qui ne sert qu'à intercepter les signaux grâce à sigwait. Ma question est la suivante: l'appel à sigwait étant bloquant, est-il gênant de ne pas terminer ce thread proprement lorsque le programme se termine naturellement?
Sylvain SF
Guillaume GOURDIN a écrit :
l'appel à sigwait étant bloquant, est-il gênant de ne pas terminer ce thread proprement lorsque le programme se termine naturellement?
la fin "naturelle" ne peut-elle pas "s'auto-signaler" (sigqueue) afin de sortir de ce thread en attente, et de l'appli. dans la foulée ?
Sylvain.
Guillaume GOURDIN a écrit :
l'appel à sigwait étant bloquant, est-il gênant de ne pas
terminer ce thread proprement lorsque le programme se termine
naturellement?
la fin "naturelle" ne peut-elle pas "s'auto-signaler" (sigqueue)
afin de sortir de ce thread en attente, et de l'appli. dans la
foulée ?
l'appel à sigwait étant bloquant, est-il gênant de ne pas terminer ce thread proprement lorsque le programme se termine naturellement?
la fin "naturelle" ne peut-elle pas "s'auto-signaler" (sigqueue) afin de sortir de ce thread en attente, et de l'appli. dans la foulée ?
Sylvain.
Patrick Lamaizière
Guillaume GOURDIN:
Bonjour à tous,
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Et c'est quoi la question sur le langage C ?
Pour ce genre de question fr.comp.os.unix est plus indiqué.
Guillaume GOURDIN:
Bonjour à tous,
je travaille actuellement une petite applicatino multi-threadée (2
threads). Mon problème est que pour termiber l'exécution, j'intercepte
les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon
application part en dead lock quand je tape Ctrl+C, et je pense que
c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Et c'est quoi la question sur le langage C ?
Pour ce genre de question fr.comp.os.unix est plus indiqué.
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Et c'est quoi la question sur le langage C ?
Pour ce genre de question fr.comp.os.unix est plus indiqué.
Antoine Leca
En news:, Patrick Lamaizière va escriure:
Guillaume GOURDIN:
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Et c'est quoi la question sur le langage C ?
Bin, la question en tant que telle est pertinente (utilise des signaux officiels, etc.)
Le problème (ce que ne peut pas savoir a priori Guillaume) est que la solution, elle, est spécifique au système qu'il utilise.
Pour ce genre de question fr.comp.os.unix est plus indiqué.
Yep.
Antoine
En news:XnsD74CCBE0EE53Dplam@dave.invalid, Patrick Lamaizière va
escriure:
Guillaume GOURDIN:
je travaille actuellement une petite applicatino multi-threadée (2
threads). Mon problème est que pour termiber l'exécution,
j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en
temps, mon application part en dead lock quand je tape Ctrl+C, et je
pense que c'est dû au fait que la fonction 'signal' n'est pas thread
safe.
Et c'est quoi la question sur le langage C ?
Bin, la question en tant que telle est pertinente (utilise des signaux
officiels, etc.)
Le problème (ce que ne peut pas savoir a priori Guillaume) est que la
solution, elle, est spécifique au système qu'il utilise.
Pour ce genre de question fr.comp.os.unix est plus indiqué.
je travaille actuellement une petite applicatino multi-threadée (2 threads). Mon problème est que pour termiber l'exécution, j'intercepte les SIGINT et SIGTERM. Mon problème est que de temps en temps, mon application part en dead lock quand je tape Ctrl+C, et je pense que c'est dû au fait que la fonction 'signal' n'est pas thread safe.
Et c'est quoi la question sur le langage C ?
Bin, la question en tant que telle est pertinente (utilise des signaux officiels, etc.)
Le problème (ce que ne peut pas savoir a priori Guillaume) est que la solution, elle, est spécifique au système qu'il utilise.
Pour ce genre de question fr.comp.os.unix est plus indiqué.
