Discussion :

[snakepierre]

Bonjour,

J'ai un objet A qui crée plusieurs objets B (dans des threads).
Dans ces objets B il y a une fonction Process possédant une boucle infinie qui lit une table en BDD.
J'aimerais stopper cette boucle depuis l'objet A vers ses objets B à la réception d'un signal.

J'ai donc ajouté un attribut dans la classe B : stopped. A la réception du signal je boucle sur mes objets B et je change la valeur de stopped, et j'ai modifié ma boucle infinie pour l'arrêter lorsque stopped est à 1.
Mais ça ne marche pas, la boucle ne s'arrête pas..

Est-ce parce que j'initialise $this, qui possède bien sûr stopped à 0 au début de fonction et qui ne change pas ?

Code :

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

1
2
3
4
5
6
7
8
9
 
sub Process
{
  my $this = shift;
  while(!$this->{stopped})
  {
   ...
  }
}

J'ai également testé en enlevant cet attribut et mettant une variable globale dans ma classe B :

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
 
our $bStopped = 0;
sub Stop
{
  $bStopped = 1;
}
sub Process
{
  my $this = shift;
  while(!$bStopped)
  {
   print $bStopped;
   ...
  }
}

J'appelle la fonction Stop sur chacun des objets B depuis A, mais ça ne change rien, le print m'affiche 0...

Est-ce que parce que j'appelle la fonction Process de mes objets B dans un thread ? Ou peut être un problème de références, je ne sais pas..

Ma question est donc, comment faire, si possible proprement, pour changer cette valeur dans chaque objet et qu'elle soit prise en compte dans la fonction ?

Merci beaucoup !

[djibril]

Peux-tu nous mettre un prog complet pour que l'on puisse tester. Car j'ai la flemme de faire le prog .

[snakepierre]

Alors voilà simplifié au max !
- perl main.pl pour lancer le truc, normalement vous avez 3 threads qui tournent..
- pour faire le stop lancer dans un autre terminal
echo "stop" | nc localhost 20203
Mais les threads tournent toujours...

Bon courage et merci !

main.pl :

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
 
#!/usr/bin/perl
 
use strict; use warnings;
use TestServer;
 
my $iPid = fork();
if($iPid == 0)
{
	my $oServer = new TestServer();
	$oServer->Start() if $oServer;
}elsif(defined $iPid)
{
	exit 0;
}else
{
	die("Process error.\n")
}

TestServer.pm :

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
#!/usr/bin/perl
 
use strict; use warnings;
use Net::Server::PreFork;
use threads;
 
use TestThread;
package TestServer;
our @ISA = qw(Net::Server::PreFork);
 
sub new
{
    my $sClass = $_[0];
    my $this = {};
    $this->{aThreads} = undef;
    bless($this, $sClass);
    return($this);
}
 
sub Start
{
	my $this = shift;
	for(my $i = 1; $i <= 3; $i++)
	{
		# création des threads
		my $oThread = new TestThread($i);
		if($oThread)
		{
			push(@{$this->{aThreads}}, $oThread);
			my $tr = threads->new(
			 sub
			 {
				$oThread->Process()
			 }
			);
			$tr->detach();
		}
	}
 
	# ici code pour gérer les requêtes de Net::Server::PreFork
	sub process_request 
	{
		my $this = shift;
		eval 
		{
		  local $SIG{'ALRM'} = sub 
		  { 
			die "Timed Out!\n" 
		  };
		  my $timeout = 1;
 
		  my $previous_alarm = alarm($timeout);
		  while(<STDIN>) 
		  {
			s/\r?\n$//;
			$this->_ProcessCommand($_);
			alarm($timeout);
			last if /quit/i;
		  }
		  alarm($previous_alarm);
		};
 
		if($@ =~ /timed out/i)
		{
			print STDOUT "Timed Out.\r\n";
			return;
		}
	}
	$this->run(
	  port => 20203
	);
}
 
sub _ProcessCommand
{
  my ($this, $sCommand) = @_;
  if($sCommand eq "stop")
  {
  	$this->Stop()
  }
}
 
sub Stop()
{
    print "Stopping...\n";
    my $this = shift;
 
	foreach my $oThread (@{$this->{aThreads}})
	{
		print STDOUT $oThread->{index} . " envoi stop \n";
		$oThread->Stop();
	}
	exit 0;
}
 
return(1);

TestThread.pm :

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
#!/usr/bin/perl
 
use strict; use warnings;
package TestThread;
 
sub new
{
    my $sClass = $_[0];
    my $this = {};
    $this->{index} = $_[1];
    $this->{bStopped} = 0;
    bless($this, $sClass);
    return($this);
}
 
sub Process
{
	my $this = shift;
	my $iIndex = $this->{index};
 
	print STDOUT "Thread $iIndex starting...\n";
	while(!$this->{bStopped})
	{
		print STDOUT "$iIndex Running...\n";
		sleep(2);
	}
	print STDOUT "$iIndex stopped\n";
}
 
sub Stop()
{
	my $this = shift;
	print STDOUT $this->{index} . " stop recu\n";
	$this->{bStopped} = 1;
}
 
return(1);

PS : je suis ouvert à toute remarque

[djibril]

Code :

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

1
2
3
C:\>echo "stop" | nc localhost 20203
'nc' n'est pas reconnu en tant que commande interne
ou externe, un programme exécutable ou un fichier de commandes.

[Beniou]

La commande nc, ou netcat, est disponible de base sur Linux (ou alors un apt-get ou yum etc. fera l'affaire). Sous windows, on peut la trouver sous forme d'archive pour installation (ex là).

Snakepierre aurait dû le préciser

[djibril]

dans ton prog, je ne vois à aucun endroit comment nc interagit avec ton prog. Il est donc impossible à ton programme d'intercepter un eventuel stop.

[snakepierre]

Excusez moi pour NC je pensais que vous aviez linux. Mais je pense qu'un simple telnet fonctionnera.

En fait je le fais grâce au module Net::Server.

Ensuite un petit bout de code qui marche très bien qui est fourni par ce module, que j'ai inséré dans ma classe, et qui intercepte les mots envoyés par le biais de NC ou un autre outil pour les traiter.

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
25
26
27
28
29
30
31
32
33
 
# ici code pour gérer les requêtes de Net::Server::PreFork
	sub process_request 
	{
		my $this = shift;
		eval 
		{
		  local $SIG{'ALRM'} = sub 
		  { 
			die "Timed Out!\n" 
		  };
		  my $timeout = 1;
 
		  my $previous_alarm = alarm($timeout);
		  while(<STDIN>) 
		  {
			s/\r?\n$//;
			$this->_ProcessCommand($_);
			alarm($timeout);
			last if /quit/i;
		  }
		  alarm($previous_alarm);
		};
 
		if($@ =~ /timed out/i)
		{
			print STDOUT "Timed Out.\r\n";
			return;
		}
	}
	$this->run(
	  port => 20203
	);

ici ma fonction ProcessCommand est appelée avec le mot tapé en paramètre. Ensuite je teste si le mot est "stop" est dans ce cas j'appelle ma fonction Stop()

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
 
sub _ProcessCommand
{
  my ($this, $sCommand) = @_;
  if($sCommand eq "stop")
  {
  	$this->Stop()
  }
}
 
sub Stop()
{
    print "Stopping...\n";
    my $this = shift;
 
	foreach my $oThread (@{$this->{aThreads}})
	{
		print STDOUT $oThread->{index} . " envoi stop \n";
		$oThread->Stop();
	}
	exit 0;
}

Le problème n'est pas là puisqu'un envoi "stop" à mon server affiche bien le "Stopping..." et "1 envoi stop", "2 envoi stop", "3 envoi stop". Donc je pense que pour tes tests tu peux te passer de NC et appeler la fonction Stop d'une autre manière.

[djibril]

La variable $this->{bStopped} ne change pas de 0 à 1 car ta procédure Process est lancée dans un thread. Le thread principal ne sait donc pas qu'elle a changé. Il faut jouer avec les partages de variables.

[snakepierre]

En effet je suis obligé de faire un thread par appel à la fonction process.

Merci du temps que tu as pris pour m'aider, mais pourrais-tu être plus explicite quand tu parles de partage de variable ? (petit exemple de code ?) Car j'ai peur que si je fais ça, je ne puisse pas changer cette variable à un seul thread, mais uniquement à tous..

[djibril]

Faudrait montrer ce que tu as fait.

[snakepierre]

J'ai créé un tableau partagé dans mon server, que je mets en paramètres de constructeur de mes threads.
Lors du stop je mets les index de mes threads dans ce tableau.
Et dans la fonction process de mes threads je teste si l'index courant est dans le tableau des threads à stopper.
Hélas j'ai beau modifier le tableau dans le serveur, mes threads ont toujours le tableau tel qu'il était initialisé.

main.pl :

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
 
#!/usr/bin/perl
 
use strict; use warnings;
use TestServer;
use Config::Auto;
use Data::Dumper;
 
my $iPid = fork();
if($iPid == 0)
{
	my $oServer = new TestServer();
	$oServer->Start() if $oServer;
}elsif(defined $iPid)
{
	exit 0;
}else
{
	die("Process error.\n")
}

TestServer.pl :

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
#!/usr/bin/perl
 
use strict; use warnings;
use Net::Server::PreFork;
use threads;
use threads::shared;
 
use TestThread;
package TestServer;
our @ISA = qw(Net::Server::PreFork);
 
sub new
{
    my $sClass = $_[0];
    my $this = {};
    $this->{aThreads} = ();
    bless($this, $sClass);
    return($this);
}
 
our @aStoppedThreads :shared = qw("cool test");
 
sub Start
{
	my $this = shift;
	for(my $i = 1; $i <= 3; $i++)
	{
		my $oThread = new TestThread($i, \@aStoppedThreads);
		if($oThread)
		{
			push(@{$this->{aThreads}}, $oThread);
			my $tr = threads->new(
			 sub
			 {
				$oThread->Process()
			 }
			);
			$tr->detach();
		}
	}
 
	sub process_request 
	{
		my $this = shift;
		eval 
		{
		  local $SIG{'ALRM'} = sub 
		  { 
			die "Timed Out!\n" 
		  };
		  my $timeout = 1;
 
		  my $previous_alarm = alarm($timeout);
		  while(<STDIN>) 
		  {
			s/\r?\n$//;
			$this->_ProcessCommand($_);
			alarm($timeout);
			last if /quit/i;
		  }
		  alarm($previous_alarm);
		};
 
		if($@ =~ /timed out/i)
		{
			print STDOUT "Timed Out.\r\n";
			return;
		}
	}
	$this->run(
	  port => 20203
	);
}
 
sub _ProcessCommand
{
  my ($this, $sCommand) = @_;
  if($sCommand eq "stop")
  {
  	$this->Stop()
  }
}
 
sub Stop()
{
    print "Stopping...\n";
    my $this = shift;
 
	foreach my $oThread (@{$this->{aThreads}})
	{
		push(@aStoppedThreads, $oThread->{index});
		print STDOUT $oThread->{index} . " ajout au stop \n";
	}
}
 
return(1);

TestThread.pl

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
25
26
27
28
29
30
31
32
33
34
 
#!/usr/bin/perl
 
use strict; use warnings;
package TestThread;
 
sub new
{
   my $sClass = $_[0];
    my $this = {};
    $this->{index} = $_[1];
    $this->{aStopped} = $_[2];
    bless($this, $sClass);
    return($this);
}
 
sub Process
{
	my $this = shift;
	my $iIndex = $this->{index};
	my @aStopped = @{$this->{aStopped}};
 
	print STDOUT "Thread $iIndex starting...\n";
	until($this->{index} ~~ @aStopped)
	{
		print STDOUT "$iIndex Running...\n";
		sleep(2);
		my $d = Data::Dumper->new([@aStopped]);
		print $d->Dump;
	}
	print STDOUT "$iIndex stopped\n";
}
 
return(1);

[djibril]

Je pense que tu n'as pas bien lu la documentation.

qw("cool test"); depuis quand déclare t-on les tableaux ainsi ?

Code :

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

our @aStoppedThreads :shared

déclare le tableau mais à aucun moment tu le partages !!

voici une documentation en français sur les threads.

Essaye déjà ça.

[snakepierre]

C'était juste pour voir si mes 2 premiers éléments étaient bien récupérés par mes threads.

J'ai effectivement lu la documentation. Et de déclarer un tableau partagé avec "our @aStoppedThreads :shared" et de passer sa référence dans le constructeur de mes objets, je ne vois pas ce que je peux faire de + La fonction share ? J'ai vu ici mais j'ai un peu du mal à comprendre et à l'adapter à mon programme.

J'ai l'impression que si le code de mon thread était dans le même fichier j'aurai pas tout ces ennuis, mais bon j'essaye de travailler en objets..

[djibril]

bon, je vais regarder ton prog.

[snakepierre]

Je t'en remercie.
En fait, on peut repartir de zéro et se dire : comment tu ferais un "serveur" qui lance des threads créant des objets, et qui peut à n'importe quel moment modifier une variable d'un de ces objets threadés ou tous...

[djibril]

Bah si on doit repartir de zéro, je ne ferais pas de threads tout simplement .
donc je me demanderai déjà, qu'est ce l'on souhaite faire ? Quel est le but de ton programme hors threads. Moins j'en mets, mieux je me porte.

[snakepierre]

En fait j'ai pas mal de serveurs de base de données alimentées par d'autres programmes et je dois lire constamment des tables de chaque serveur et faire des actions.
D'où un thread par serveur de base de données, qui attaque infiniment les tables et fait les actions.
Et j'ai besoin de "demander" des choses à ces threads, comme se mettre en pause, s'arrêter ou m'envoyer des status, etc.. J'ai donc besoin de communiquer avec eux, depuis mon objet principal qui les a créé.

[djibril]

Pourquoi faire un thread par serveur. Pourquoi ne pas lancer tout simplement un programme qui boucle à l'infini sur chaque serveur en deamon ?

[snakepierre]

Je n'ai hélas pas la possibilité, je dois tout faire sur un seul PC qui attaque d'autres serveurs de BDD d'où mon idée des threads...
Comment ferais-tu dans ce cas ?

[djibril]

J'ai rien compris.
Tu as par exemple deux serveurs A et B contenant chacun une BD. Et toi tu cherches à envoyer des actions depuis ton PC. Tu as 3 machines, c'est bien ça ?