Discussion :

[Nao13090]

Bonjour !

J'ai un léger soucis, lorsque je lance une tâche à partir d'un processus principal, celle-ci continue à tourner même lorsque je ferme le programme.

Plus précisément, le processus appelé est censé écrire en boucle dans un fichier, mais même lorsque je ferme le programme j'ai l'impression que la boucle continue à s'exécuter, le fichier ne cesse de se remplir.

Voici les codes si celà peut aider :

Processus principal :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
int main()
{
	pid_t pid;
	pid = fork();
	// traitement du premier processus fils
	if (pid == 0)
	{
		//processus gps 
	}
 
 
	else
	{
		pid = fork();
		// traitement du 2ème fils
		if (pid == 0)
		{
			execlp("Comm.exe","Comm.exe",NULL);
		}
	}	
	// retour au père
	return 0;
}

Processus appelé (Comm.exe) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
Code : C++ - Sélectionner
int main()
{
	RS232 PortCom;
	Recepteur ICOM;	
 
	pid_t currentpid;
	currentpid = getpid();
 
	PortCom.OpenPort("/dev/ttyS0", O_RDWR);
	PortCom.ConfigPort1();
 
	while(1)
	{
	ofstream file("file.txt", ios::out | ios::app);
	file << "force du signal : " << ICOM.getSmetre(&PortCom) << "%" << endl;
	file.close();
	sleep(1);
	}
}

Voila j'ai essayé de mettre un kill(getpid(),SIGTERM) mais ça ne termine pas l'écriture dans le fichier

[darkman19320]

Bonjour,

Je ne pense pas que ça puisse résoudre ton problème mais pourquoi tu ne sors pas le ofstream file de la boucle while:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
...
 
ofstream file("file.txt", ios::out | ios::app);
 
while(1)
{
	file << "force du signal : " << ICOM.getSmetre(&PortCom) << "%" << endl;
	sleep(1);
}
 
file.close();

Ca éviterai d'ouvrir fermer le flux tout le temps.

[Ekleog]

Je pense qu'il faudrait plutôt mettre un kill(pid, SIGTERM);, avec pid le résultat de fork. Parce que kill(getpid(), SIGTERM); va faire que ton processus se suicidera -- pas très utile, n'est-ce pas ?
Par ailleurs, lorsque tu appelles fork, il n'y a pas vraiment deux fils. Le père reçoit comme retour le PID du fils, et le fils 0 (de mémoire). Il y a donc une hiérarchie, et seul le père peut tuer le fils (le fils n'ayant pas le PID du père).
Si tu veux que le fils tue le père, il faudra avoir stocké getpid() avant l'appel de fork.

[Trademark]

Il existe l'instruction getppid() pour connaitre le pid de son père.

Sinon c'est normal que ça continue à s'exécuter vu que c'est pas le même processus que tu termines. Tes processus sont indépendants et c'est pas parce que tu termines le processus père que les processus fils se terminent aussi. Si tu termines le père avant les fils, alors les fils deviennent des processus orphelins et sont rattachés à init (processus avec le pid 1). Ce sont des processus deamon. Si ce n'est pas ce que tu souhaites, alors le père doit attendre la fin de son fils avec l'instruction wait ou waitpid.