Les instructions 2 et 3 dure 10 minutes et j'aimerai qu'elle s'execute en meme temps et non de maniere sequencielle
Alors j'utilise les procesus pere et fils :
########### CODE ########## Instruction 1 my $pid = fork(); if ($pid) {Instruction 2} else {Instruction 3} Instruction 4 ####### FIN DU CODE #######
Le probleme c'est que [...]
Je vois quelques fragments de Perl dans ce message, mais pas assez pour comprendre le programme qui pose le problème.
Merci de présenter un programme bref, mais complet, qui montre le problème.
Paul Gaborit
À (at) Mon, 2 Oct 2006 14:44:59 +0200, "Lincoln B" écrivait (wrote):
Alors j'utilise les procesus pere et fils :
########### CODE ########## Instruction 1 my $pid = fork(); if ($pid) {Instruction 2} else {Instruction 3} Instruction 4 ####### FIN DU CODE #######
Le probleme c'est que les instruction 1 et 4 sont executé 2 fois (pere et fils)
Je m'embrouille la, et je comprend plus rien.
C'est effectivement du pseudo-code et non du Perl.
Ce qui est certain : l'instruction 1 n'est exécuter qu'une seule fois (par le père puisque le fils n'existe pas encore).
La 2 et la 3 sont respectivement exécutées par le père (le pid retourné par fork() n'est pas nul) et le fils (le pid retourné par fork() est nul).
Et dans votre cas, l'instruction 4 sera effectivement executée deux fois (par le père et le fils).
Pour s'en sortir, il suffit de dire au fils de se sacrifier juste après avoir terminer l'instruction 3 :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour le sacrifice du fils } # le pere continue Instruction 4 ####### FIN DU PSEUDO-CODE ######
Pour s'assure que l'instruction 4 n'est exécutée par le père que lorsque le fils a terminé l'instruction 3, il suffit d'ajouter un wait() :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour se sacrifier } # le pere attend la fin du fils wait(); # et continue... Instruction 4 ####### FIN DU PSEUDO-CODE ######
Est-ce plus claire ?
Sinon, lire 'perlipc'...
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
À (at) Mon, 2 Oct 2006 14:44:59 +0200,
"Lincoln B" <c-note@hotmail.fr> écrivait (wrote):
Alors j'utilise les procesus pere et fils :
########### CODE ##########
Instruction 1
my $pid = fork();
if ($pid) {Instruction 2}
else {Instruction 3}
Instruction 4
####### FIN DU CODE #######
Le probleme c'est que les instruction 1 et 4 sont executé 2 fois (pere et
fils)
Je m'embrouille la, et je comprend plus rien.
C'est effectivement du pseudo-code et non du Perl.
Ce qui est certain : l'instruction 1 n'est exécuter qu'une seule fois
(par le père puisque le fils n'existe pas encore).
La 2 et la 3 sont respectivement exécutées par le père (le pid
retourné par fork() n'est pas nul) et le fils (le pid retourné par
fork() est nul).
Et dans votre cas, l'instruction 4 sera effectivement executée deux
fois (par le père et le fils).
Pour s'en sortir, il suffit de dire au fils de se sacrifier juste
après avoir terminer l'instruction 3 :
######### PSEUDO- CODE ##########
Instruction 1
my $pid = fork();
if ($pid) {
# le pere
Instruction 2
} else {
# le fils
Instruction 3
exit(0); # pour le sacrifice du fils
}
# le pere continue
Instruction 4
####### FIN DU PSEUDO-CODE ######
Pour s'assure que l'instruction 4 n'est exécutée par le père que
lorsque le fils a terminé l'instruction 3, il suffit d'ajouter un
wait() :
######### PSEUDO- CODE ##########
Instruction 1
my $pid = fork();
if ($pid) {
# le pere
Instruction 2
} else {
# le fils
Instruction 3
exit(0); # pour se sacrifier
}
# le pere attend la fin du fils
wait();
# et continue...
Instruction 4
####### FIN DU PSEUDO-CODE ######
Est-ce plus claire ?
Sinon, lire 'perlipc'...
--
Paul Gaborit - <http://perso.enstimac.fr/~gaborit/>
Perl en français - <http://perl.enstimac.fr/>
À (at) Mon, 2 Oct 2006 14:44:59 +0200, "Lincoln B" écrivait (wrote):
Alors j'utilise les procesus pere et fils :
########### CODE ########## Instruction 1 my $pid = fork(); if ($pid) {Instruction 2} else {Instruction 3} Instruction 4 ####### FIN DU CODE #######
Le probleme c'est que les instruction 1 et 4 sont executé 2 fois (pere et fils)
Je m'embrouille la, et je comprend plus rien.
C'est effectivement du pseudo-code et non du Perl.
Ce qui est certain : l'instruction 1 n'est exécuter qu'une seule fois (par le père puisque le fils n'existe pas encore).
La 2 et la 3 sont respectivement exécutées par le père (le pid retourné par fork() n'est pas nul) et le fils (le pid retourné par fork() est nul).
Et dans votre cas, l'instruction 4 sera effectivement executée deux fois (par le père et le fils).
Pour s'en sortir, il suffit de dire au fils de se sacrifier juste après avoir terminer l'instruction 3 :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour le sacrifice du fils } # le pere continue Instruction 4 ####### FIN DU PSEUDO-CODE ######
Pour s'assure que l'instruction 4 n'est exécutée par le père que lorsque le fils a terminé l'instruction 3, il suffit d'ajouter un wait() :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour se sacrifier } # le pere attend la fin du fils wait(); # et continue... Instruction 4 ####### FIN DU PSEUDO-CODE ######
Est-ce plus claire ?
Sinon, lire 'perlipc'...
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
Lincoln B
Tres claire merci de ta reponses
"Paul Gaborit" a écrit dans le message de news:
À (at) Mon, 2 Oct 2006 14:44:59 +0200, "Lincoln B" écrivait (wrote):
Alors j'utilise les procesus pere et fils :
########### CODE ########## Instruction 1 my $pid = fork(); if ($pid) {Instruction 2} else {Instruction 3} Instruction 4 ####### FIN DU CODE #######
Le probleme c'est que les instruction 1 et 4 sont executé 2 fois (pere et fils)
Je m'embrouille la, et je comprend plus rien.
C'est effectivement du pseudo-code et non du Perl.
Ce qui est certain : l'instruction 1 n'est exécuter qu'une seule fois (par le père puisque le fils n'existe pas encore).
La 2 et la 3 sont respectivement exécutées par le père (le pid retourné par fork() n'est pas nul) et le fils (le pid retourné par fork() est nul).
Et dans votre cas, l'instruction 4 sera effectivement executée deux fois (par le père et le fils).
Pour s'en sortir, il suffit de dire au fils de se sacrifier juste après avoir terminer l'instruction 3 :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour le sacrifice du fils } # le pere continue Instruction 4 ####### FIN DU PSEUDO-CODE ######
Pour s'assure que l'instruction 4 n'est exécutée par le père que lorsque le fils a terminé l'instruction 3, il suffit d'ajouter un wait() :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour se sacrifier } # le pere attend la fin du fils wait(); # et continue... Instruction 4 ####### FIN DU PSEUDO-CODE ######
Est-ce plus claire ?
Sinon, lire 'perlipc'...
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
Tres claire merci de ta reponses
"Paul Gaborit" <Paul.Gaborit@invalid.invalid> a écrit dans le message de
news: wt9sli6q0l7.fsf@marceau.enstimac.fr...
À (at) Mon, 2 Oct 2006 14:44:59 +0200,
"Lincoln B" <c-note@hotmail.fr> écrivait (wrote):
Alors j'utilise les procesus pere et fils :
########### CODE ##########
Instruction 1
my $pid = fork();
if ($pid) {Instruction 2}
else {Instruction 3}
Instruction 4
####### FIN DU CODE #######
Le probleme c'est que les instruction 1 et 4 sont executé 2 fois (pere et
fils)
Je m'embrouille la, et je comprend plus rien.
C'est effectivement du pseudo-code et non du Perl.
Ce qui est certain : l'instruction 1 n'est exécuter qu'une seule fois
(par le père puisque le fils n'existe pas encore).
La 2 et la 3 sont respectivement exécutées par le père (le pid
retourné par fork() n'est pas nul) et le fils (le pid retourné par
fork() est nul).
Et dans votre cas, l'instruction 4 sera effectivement executée deux
fois (par le père et le fils).
Pour s'en sortir, il suffit de dire au fils de se sacrifier juste
après avoir terminer l'instruction 3 :
######### PSEUDO- CODE ##########
Instruction 1
my $pid = fork();
if ($pid) {
# le pere
Instruction 2
} else {
# le fils
Instruction 3
exit(0); # pour le sacrifice du fils
}
# le pere continue
Instruction 4
####### FIN DU PSEUDO-CODE ######
Pour s'assure que l'instruction 4 n'est exécutée par le père que
lorsque le fils a terminé l'instruction 3, il suffit d'ajouter un
wait() :
######### PSEUDO- CODE ##########
Instruction 1
my $pid = fork();
if ($pid) {
# le pere
Instruction 2
} else {
# le fils
Instruction 3
exit(0); # pour se sacrifier
}
# le pere attend la fin du fils
wait();
# et continue...
Instruction 4
####### FIN DU PSEUDO-CODE ######
Est-ce plus claire ?
Sinon, lire 'perlipc'...
--
Paul Gaborit - <http://perso.enstimac.fr/~gaborit/>
Perl en français - <http://perl.enstimac.fr/>
À (at) Mon, 2 Oct 2006 14:44:59 +0200, "Lincoln B" écrivait (wrote):
Alors j'utilise les procesus pere et fils :
########### CODE ########## Instruction 1 my $pid = fork(); if ($pid) {Instruction 2} else {Instruction 3} Instruction 4 ####### FIN DU CODE #######
Le probleme c'est que les instruction 1 et 4 sont executé 2 fois (pere et fils)
Je m'embrouille la, et je comprend plus rien.
C'est effectivement du pseudo-code et non du Perl.
Ce qui est certain : l'instruction 1 n'est exécuter qu'une seule fois (par le père puisque le fils n'existe pas encore).
La 2 et la 3 sont respectivement exécutées par le père (le pid retourné par fork() n'est pas nul) et le fils (le pid retourné par fork() est nul).
Et dans votre cas, l'instruction 4 sera effectivement executée deux fois (par le père et le fils).
Pour s'en sortir, il suffit de dire au fils de se sacrifier juste après avoir terminer l'instruction 3 :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour le sacrifice du fils } # le pere continue Instruction 4 ####### FIN DU PSEUDO-CODE ######
Pour s'assure que l'instruction 4 n'est exécutée par le père que lorsque le fils a terminé l'instruction 3, il suffit d'ajouter un wait() :
######### PSEUDO- CODE ########## Instruction 1 my $pid = fork(); if ($pid) { # le pere Instruction 2 } else { # le fils Instruction 3 exit(0); # pour se sacrifier } # le pere attend la fin du fils wait(); # et continue... Instruction 4 ####### FIN DU PSEUDO-CODE ######
Est-ce plus claire ?
Sinon, lire 'perlipc'...
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/> Perl en français - <http://perl.enstimac.fr/>
