[Thread] Stopper un thread pendant que les autres tournent

Version imprimable

Salut à tous,

Je développe un petit exemple pour bien saisir l'idée des threads.
J'ai lancé une série de thread avec un numéro associé à chacun.
J'aimerai pouvoir mettre un thread en pause pendant un certain temps (le thread est choisi au hasard) mais les autres doivent continuer l'exécution.

En fait j'ai lancé une série de thread qui font appel a une fonction d'affichage. Chaque thread affiche un nom et un numéro au hasard. L'affichage se fait toutes les 2 secondes.

J'ai essayé 2-3 trucs mais dès que j'en met un en sleep, le thread garde la main mise sur l'exécution et les autres sont en attente.

Je cherche une façon de procéder
Code:

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 while(temp2 <= (temp+120000)) { if(temp2 == (temp+delai)) { System.out.println("***************Debut iteration " + iteration + " ************"); int hasard = (int)(Math.random() * tabT.size()); ThreadEnfant ta = tabT.get(hasard); //Ici mettre un thread en sleep for(int i = 0; i < tabT.size(); i++) { ThreadEnfant t = tabT.get(i); String retour = t.crier(); System.out.println(retour); } delai += 2000; System.out.println("***************Fin iteration " + iteration + " ************"); iteration++; } temp2 = System.currentTimeMillis(); } System.out.println("-----------Fin---------");
(Les threads sont déjà lancé dans le début du code et les variables sont instanciées)

Merci d'avance

16/01/2009, 13h24
Alkhan

bonjour,

peut tu montrer le code de tes threads et comment tu les lances ?
Le problème pourrait venir de la facon dont tu as fait tous ca

Nan c'est secret défense :mrgreen:

Je ne met pas l'interface ni la classe Chat.java, cette dernière est la copie conforme de Chien.java

ThreadEnfant.java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ThreadEnfant extends Thread
{
    private Animal a;
    private int numT;
    public ThreadEnfant(Animal a, int numT)
    {
        this.a = a;
        this.numT = numT;
    }
    public int getNum()
    {
        return numT;
    }
    public void run()
    {
        crier();
    }
    public String crier()
    {
        return a.cri();
    }
}

Chien.java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Chien implements Animal
{
    private String nom;
    public Chien()
    {
    }
    public void setNom(String nom)
    {
        this.nom = nom;
    }
    public synchronized String cri()
    {
        int tab[] =  {1,2,3,4,5,6,7,8,9,10};
        int alea = (int) (Math.random() * tab.length);
        return "Le chien " + nom + " aboie!!! " + alea;
    }
}

Et mon main

Code:

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
98
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class Main
{
    public static void main(String[] args) throws ClassNotFoundException
    {
        ArrayList<String> animaux = new ArrayList<String>();
        animaux.add("threadinterface.Chien");
        animaux.add("threadinterface.Chat");
 
        ArrayList<String> nom_chat = new ArrayList<String>();
        nom_chat.add("Usty");
        nom_chat.add("Moustique");
        nom_chat.add("Raton");
        nom_chat.add("Mia");
        nom_chat.add("Loustique");
 
        ArrayList<String> nom_chien = new ArrayList<String>();
        nom_chien.add("Loutre");
        nom_chien.add("Archimede");
        nom_chien.add("Lala");
        nom_chien.add("Louuuu");
        nom_chien.add("Caligula");
 
 
        int numT = 1;
 
        ArrayList<ThreadEnfant> tabT = new ArrayList<ThreadEnfant>();
        System.out.println("---------Debut------------");
        for(int i = 0; i < animaux.size(); i++)
        {
            for(int j = 0; j < 5; j++)
            {
                Class animal = Class.forName(animaux.get(i));
                try
                {
                    Animal ani = (Animal)animal.newInstance();
                    ani.setNom(nom_chat.get(j));
                    ThreadEnfant t = new ThreadEnfant(ani,numT);
                    t.start();
                    tabT.add(t);
                    numT++;
                } 
                catch (InstantiationException ex)
                {
                    Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                } 
                catch (IllegalAccessException ex)
                {
                    Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
        System.out.println("--------Affichage avec délai---------");
        double temp = System.currentTimeMillis();
        double temp2 = temp;
        int delai = 2000;
        int iteration = 1;
 
        while(temp2 <= (temp+120000))
        {
            if(temp2 == (temp+delai))
            {
                try {
                    System.out.println("***************Debut iteration " + iteration + " ************");
                    int hasard = (int) (Math.random() * tabT.size());
                    ThreadEnfant ta = tabT.get(hasard);
                    ta.sleep(10000);
                    for (int i = 0; i < tabT.size(); i++) {
                        ThreadEnfant t = tabT.get(i);
                        String retour = t.crier();
                        System.out.println(retour);
                        /*if(t.isAlive())
                        {
                        System.out.println("Le thread qui a planté est le numéro : " + t.getNum());
                        }
                        String retour = t.crier();
                        if(retour == null)
                        {
                        System.out.println("Le thread qui a planté est le numéro : " + t.getNum());
                        }
                        else
                        System.out.println(retour);*/
                    }
                    delai += 2000;
                    System.out.println("***************Fin iteration " + iteration + " ************");
                    iteration++;
                } catch (InterruptedException ex) {
                    Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            temp2 = System.currentTimeMillis();
        }
        System.out.println("-----------Fin---------");
    }
}

Voilou ;)

16/01/2009, 13h50
BugFactory

Attention, la méthode sleep est une méthode statique qui s'applique au thread en cours! D'ailleurs si vous utilisez Eclipse vous aurez un warning à la ligne

Code:

ta.sleep(10000);

car malgré les apparences, sleep ne s'applique pas à ta mais au thread main.
16/01/2009, 14h25
NutellaPiou

D'accord. Je vais essayer en créant un thread parent. J'y mettrai le code adéquat.

Merci pour votre réponse.
16/01/2009, 16h28
NutellaPiou

J'ai essayé en modifiant un peu mais je n'arrive pas. Dès que je fais un sleep, l'exécution attend que le thread se réveille.

Comment pourrais-je faire sur l'exemple donné?

Merci d'avance.
16/01/2009, 17h20
dinobogan

Tu ne fais pas de multi-thread. Le fait d'appeler la méthode "crier" sur tes Thread est mono-Thread : tu restes dans le Thread principal.
Une fois construit un Thread, tu fais "start". Donc le ThreadEnfant va appeler sa méthode "run", donc "crier" une seule fois puis il meurt.
Ensuite, dans ton "main", ton tableau de ThreadEnfant (qui sont tous morts) se transforme en une simple liste de conteneur.
Revoit la conception en pensant qu'un Thread vit par lui même. La pause doit être effectuer par un "wait" dans la méthode "run" des Thread. Le "main" doit se contenter d'attendre la fin d'exécution de tous les Thread.
16/01/2009, 17h38
NutellaPiou

C'est juste, je m'en suis rendu compte en reparcourant mon code (qui n'est d'ailleurs pas très clair =/)

Je vais repenser tout ça comme tu dis.

Merci et bon w-e

Bonjour,

Il y a un truc que je ne pige pas,

Par exemple dans la méthode run d'un thread parent, dans une boucle, je fais appel à des threads enfants. Une fois que l'on sort de la boucle, tout les threads enfants sont mort si j'ai bien compris.

Mais comment faire pour lancer tout les threads enfants sans que ceux-ci meurent. Ils doivent tourner indéfiniment.

Main
Code:

1 2 3 4 5 6 7 8 public class Main { public static void main(String[] args) { ThreadParent tP = new ThreadParent(); tP.start(); } }
ThreadParent
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class ThreadParent extends Thread { public ThreadParent() { } public void run() { for(int i = 0; i < 10; i++) { ThreadEnfant t = new ThreadEnfant(); t.start(); } } }
ThreadEnfant
Code:

1 2 3 4 5 6 7 8 9 10 public class ThreadEnfant extends Thread { public ThreadEnfant() { } public void run() { System.out.println("Damned, j'comprend rien =O "); } }
Ce que je cherche à faire c'est une fois les enfants lancés, tout les x temps, ils se remettent à jour. Et de temps en temps j'en met un en pause pendant que les autres tournent (donc se mettent à jour)

Merci d'avance

19/01/2009, 11h29
dinobogan

Pour les boucles infinies et la mise en pause d'un Thread, le mieux est de lire la doc de Sun. Ca traite indirectement de ton problème, avec tout les exemples de code nécessaire pour faire ce que tu veux.
19/01/2009, 11h41
adiGuba
Salut,

Je crois que tu as mal compris le fonctionnement de la classe Thread.

Lorsque tu instancies un objet de type Thread et que tu appelles sa méthode start(), celle-ci va :
- Créer un nouveau thread (processus léger) aurpès du systême hôte.
- Le processus léger va alors se contenter d'exécuter la méthode run()
Donc si ta méthode run(), le thread finira aussitôt qu'elle sera exécuté.
En gros le thread se termine en même temps que la méthode run().

Donc si tu veux voir tes threads tourner indéfiniment, ta méthode run() doit comporter une boucle infini. Maintenant tu peux aussi utiliser des outils plus avancée comme les Timers ou les Executors...

Mais dans tous les cas l'utilisation des threads nécessite une bonne compréhension de leurs fonctionnements, et un minimum de lecture s'impose :
a++
19/01/2009, 12h04
NutellaPiou

J'ai déjà lu 3 fois ces tutos =/ faut croire que je comprend toujours pas ^^

Je vais reprendre étape par étape.

Merci à vous 2
28/01/2009, 11h17
NutellaPiou
Bonjour à tous,

Je relance ce topic parce que j'aimerai avoir une petite explication supplémentaire sur un point de théorie.

J'ai lu (et même re,re,relu :mouarf:) dans le tuto :

Citation:

Un Thread dans un état mort est un Thread qui est sorti de sa méthode run() soit de manière naturelle, soit de manière subite (Exception non interceptée).

Dans mon code et dans la méthode run() de mon thread, je fais une boucle infinie :
Code:

1 2 3 4 5 6 7 public void run() { while(true) { //traitements } }
Mes traitements sont :
- Un Class.forname
- Création d'un statement sur une connection
- Exécution d'une query
Je catch les exeptions associées à ces différents traitements.

Pour en revenir à la théorie :
1. On sort de la méthode run()
  Vu qu'on est jamais censé sortir du while, dois-je relancer le thread en sortie de ce while par précaution? Ou ça ne servirait à rien? (Je penche plutôt pour la 2ème solution mais c'est pour être sûr)
2. Exception non testée
  C'est ici que c'est flou pour moi. Dans ce cas, le thread serait mort et dans mon programme, je dois le relancer (relancer = recréer un thread avec les même paramètres. Je sais que c'est impossible de relancer un thread mort). Mais comment faire? Je dois tester à tout moment l'état de mon thread avec la méthode isAlive()? Et dans le cas où cette méthode me retournerai false, je dois relancer le thread?
Quelqu'un pourrait-il m'éclairer ou simplement me dire si je suis dans la bonne direction?

D'avance merci.

< Nutella >
30/01/2009, 12h45
NutellaPiou
Bon et bien j'ai résolu le problème.

J'ai stocké chaque Thread dans un ArrayList. Dans une méthode je teste si chaque thread est vivant avec :
Code:

1 2 3 4 if(!children.get(i).isAlive()) { //traitements pour lancer un nouveau thread identique au thread mort. }
Et cette méthode est appelée toutes les x secondes.

Quand je parlais de relancer un thread, il s'agissait de créer un nouveau thread avec les même propriétés que le thread mort et de le démarrer.

Enfin voilà, CQFD (comme on dit :oops:)