Discussion :

[Mr_Brown]

Bonjour,
J'essaie de capturer le signal SIGINT pour quitter proprement mon script perl qui fait tourner une Thread. Mais voilà le problème, J'aimerais que mon thread finisse ce qu'il a à faire et rende la main au script perl principal avant que que ce dernier ne quitte aussi. L'exemple qui suit ne fait rien de particulier. Le thread affiche une chaine de caractère jusqu'à ce que la variable partagée soit modifiée. Ensuite c'est le script perl principal qui s'arrête.

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
 
#! /usr/bin/perl
use threads;
use threads::shared;
 
my $flag : shared = 0;
$thr1 = threads->new(sub {
    lock($flag);
    while (!$flag) {
        print "thread\n";
        sleep(3);
        lock($flag);
    }
});
$SIG{INT} = sub {
    $thr2 = threads->new(sub {
        lock($flag);
        $flag = 1;
    });
    $thr2->join;
    $thr1->join;
    exit;
};
$thr1->join;

(Je ne sais pas s'il est nécessaire de faire un "lock" pour les accès en lecture sur une variable partagée dans un thread)
Dans le raisonnement, le script perl ne devrait pas quitter sans que le thread soit terminé. Dans mon code c'est autre chose :s
Je lance le script, "thread" est affiché en boucle, mais je n'arrive pas à quitter proprement avec la commande "ctrl+c", la boucle ne se termine pas (mon OS : SLES 10, juste au cas où ).
Auriez-vous des idées?
Merci.
--
Mr_Brown

[Jedai]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#! /usr/bin/perl
use threads;
use threads::shared;
 
my $flag : shared = 0;
$thr1 = threads->new(sub {
    lock($flag);
    while (!$flag) {
        print "thread\n";
        sleep(3);
        lock($flag);
    }
});

Regarde ton premier lock(), il est dans la portée de la sub, donc il ne se "unlock" qu'en sortant de la sub, autrement dit $flag est locké dès l'entrée dans la sub() et reste locké, donc personne ne peut la modifier, et ainsi la boucle est sans fin...
Ce que tu veux faire, c'est plutôt :

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
#! /usr/bin/perl
use threads;
use threads::shared;
 
my $flag : shared = 0;
$thr1 = threads->new(sub {
  while (1) {
  { 
    lock($flag);
    unless( $flag ) {
      print "thread\n";
      return;
    }
  }
    sleep(3);
  }
});

Mais tu peux faire ça bien plus proprement et efficacement avec un cond_wait() et un cond_broadcast() :

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
#! /usr/bin/perl
use threads;
use threads::shared;
 
my $flag : shared = 0;
$thr1 = threads->new(sub {
  lock($flag);
  cond_wait( $flag ) until $flag;
  print "thread\n";
});
$SIG{INT} = sub {
  $thr2 = threads->new(sub {
    lock($flag);
    $flag = 1;
    cond_broadcast($flag);
  });
  $thr2->join;
  $thr1->join;
  exit;
};
$thr1->join;

--
Jedaï

[Mr_Brown]

Merci pour ta réponse!
Mais ça ne fonctionne toujours pas, je n'arrive pas à sortir de ma boucle. :s Sinon, juste pour précision, je veux que mon thread $thr1 s'arrete sur le changement de valeur de la variable $flag.

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
#! /usr/bin/perl
use threads;
use threads::shared;
 
my $flag : shared = 0;
$thr1 = threads->new(sub {
  lock($flag);
  cond_wait( $flag ) until $flag;
  print "thread\n";
});
$SIG{INT} = sub {
  $thr2 = threads->new(sub {
    lock($flag);
    $flag = 1;
    cond_broadcast($flag);
  });
  $thr2->join;
  $thr1->join;
  exit;
};
$thr1->join;

--
Jedaï

Donc ici, il vaut mieux l'initialiser à 1 et le modifier à 0 dans le deuxième thread $thr2, non?

[Jedai]

Je crois que mon code est correct, d'ailleurs ceci fonctionne :

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
#! /usr/bin/perl
use strict; use warnings;
 
use threads;
use threads::shared;
 
my $flag : shared = 0;
my $thr1 = threads->create(sub {
  lock($flag);
  print "hello !\n";
  cond_wait( $flag ) until $flag;
  print "thread\n";
});
 
my $thr2 = threads->create(sub {
    lock($flag);
    $flag = 1;
    cond_signal($flag);
});
 
$thr2->detach;
$thr1->join;
 
__END__

Malheureusement, mêler les signaux et les threads semble donner des résultats très mitigé. Je te recommande d'abandonner cette conception...
Si tu nous dis ce que tu veux faire, nous pourrons peut-être te suggérer des alternatives.

--
Jedaï