Discussion :

[dummygreg]

bonjour,

y a t il un moyen de contourner le fait que l'accès aux variables d'une classe à partir d'une enum interne oblige lesdites variables à être static? de plus, grand débat philosophique, pourquoi une enum est un type de classe static? le but de la programmation objet n'est-il pas de créer des objets?

[verbose]

La programmation orientée objet n'interdit pas de faire des appels static. On retrouve même ce genre d'appel dans des patterns reconnus et éprouvés comme Singleton ou Factory.

Par ailleurs, les enums ne sont pas des solutions pour résoudre des problèmes d'architecture. Ils servent uniquement à typer des valeurs discrètes, au lieu de passer des paramètres génériques comme un String ou un int.

[dummygreg]

en fait, je voudrais utiliser l'enum en temps que machine à états d'un thread, grâce à la possibilité d'ajouter des attributs et méthodes aux enums. Ce thread modifie une interface swing.

Le fait que les enum soient static implique donc que ma méthode marcherait seulement si j'ai une seule instance de ma classe, ou que ma classe est terminale dans un arbre de généralisation. le problème est que le thread que j'utilise est contenue en classe interne d'un classe abstraite étant généralisé. je devrais donc mettre le thread dans chacune des classes généralisant la classe abstraite. Pas très efficace comme méthode. enfin bon si c'est la solution.

(c'est peut-être pas très clair...)

[adiGuba]

Salut,

y a t il un moyen de contourner le fait que l'accès aux variables d'une classe à partir d'une enum interne oblige lesdites variables à être static?

Pourrais-tu préciser ce que tu veux faire précisément ??

[edit] Tu as répondus entre-temps... mais j'ai une autre question : Pourquoi utiliser une enum pour cela ????

de plus, grand débat philosophique, pourquoi une enum est un type de classe static? le but de la programmation objet n'est-il pas de créer des objets?

Au niveau d'une classe le mot-clef static n'a pas la même signification que pour un attribut...

Pour une classe cela signifie qu'elle n'est pas implicitement lié à une instance de la classe "conteneur"... Ce qui est tout à fait logique pour une enum !

a++

[dummygreg]

il s'agit en fait d'un thread qui parcoure un tableau et affiche les résultats sur une interface swing. c'est un thread de lecture dont la machine a 3 états, l'état lecture, l'état pause, et l'état stop. J'ai fait comme cela car mes tentatives au départ en utilisant les methodes wait() stop() et notify() me conduisaient dans le mur.

voici le code du thread :

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
 
public class LectureThread extends Thread{
        private static JPanel panelAModifier;
        private static LecturePanel controlLecture;
        public static Mode mode;
        /**
         * la machine à état du thread de lecture
         */
        protected enum Mode{
        Stop{
           public void pause(){
               mode=Stop;
           }
 
        },
        Lecture{
            public void action(){
                ArrayList<Object> listeAParcourir = getListe();
                if(index<listeAParcourir.size()){
 
                    panelAModifier.update(listeAParcourir.get(index));
                    controlLecture.updatePositionSlider(index);
 
 
                    index++;
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException ex) {
 
                        }
                }else{
                    stop();
                }
            }
        },
        Pause;
        public int index=1;
        public void action(){       }
        public void pause(){  mode=Pause;}
        public void stop(){ 
            index=1;
            mode= Stop;
            controlLecture.updatePositionSlider(index);
        }
        public void lecture(){mode=Lecture;}
    }
 
        /*
         * le thread de lecture
         */
        public LectureThread(JPanel owner, LecturePanel controleur){
            LectureThread.panelAModifier=owner;
            LectureThread.controlLecture=controleur;
            mode = Mode.Stop;
 
        }
 
        public void run(){
            while(true){
                mode.action();
            }
 
        }
 
 
    }

je pense que c'est assez éloquent de mon incompétence sur les différences, static/non-static. en effet ma façon de penser dans ce cas la j'utilise static uniquement pour permettre l'accession aux attributs dans la machine à états mais les implications sont bien plus grandes que ça.

[adiGuba]

Ton code n'est pas très compréhensible...
Tu as un thread qui a un état qui peut modifier l'état du thread


De plus si je comprend bien, lorsque tu es en pause ou arrêté, cela revient à appeler une méthode action() vide, donc à faire ceci :

Code :

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

1
2
3
while(true){
                // RIEN
            }

Une belle méthode d'attente active qui va prendre 100% du CPU pour rien !!!


Bref : détailles plutôt ton objectifs exact plutôt que la manière dont tu veux le faire...


a++

[dummygreg]

mon objectif est de faire un thread qui parcoure un tableau avec une pause entre chaque case. ce thread peut être mis dans 3 états, un état lecture dans lequel il parcoure le tableau jusqu'au bout, un état pause il n'avance pas dans le tableau et conserve en mémoire l'index de la case à lire, et un état stop ou l'on remet l'index de la case courante à 0. j'avais essayé au départ en utilisant les methodes wait(), et notify() mais j'obtenais des Exceptions a tire l'arigot (larigot, l'arigaux, l'art y go, ... enfin voila quoi).

EDIT : et l'état de ce thread doit être modifiable grâce à une interface swing bien sur.

[professeur shadoko]

j'avais essayé au départ en utilisant les methodes wait(), et notify() mais j'obtenais des Exceptions a tire l'arigot (larigot, l'arigaux, l'art y go, ... enfin voila quoi).

<ton paternaliste: mille fois pardon!>
un petit conseil général: quand il y a des exceptions il vaut mieux y faire face plutot que d'essayer d'y échapper.
</ton paternaliste>
on peut voir une idée de ces exceptions (ce ne serait pas par hasard "not owner"?)

[dummygreg]

a vrai dire je me souviens plus trop des exceptions. mais elles arrivaient au moment du notify(). en fait j'avais réduit ma machine à état à 2 états, et utilisé un boolean pour le wait() si le boolean était true on passait dans une partie du code ne contenant qu'un wait(). on passait le boolean à true grâce à une méthode interne au thread l'hypothèse que j'ai alors faite c'est que appeler une méthode sur un objet qui exécute déjà une méthode entraine un break de la méthode en cours au profit de la méthode appelé. comme il est impossible de restarter un thread (pourtant en mode daemon), le méthode notify() m'envoyait dans les cordes. donc la methode start nikel le tableau est parcouru. des que j'agit sur le thread pour le bloquer, ben ca marchait trop bien en fait.

[professeur shadoko]

pas trop compris..
euh ton boolean était volatile on non?

[dummygreg]

euh désolé mais je ne sais pas a quoi sert le mot clef volative.

je vais tenter de réécrire mon code de mémoire, attention ce n'est pas du copier coller de code fonctionnel.

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
 
public class LectureThread extends Thread{
              private boolean wait;
              private boolean isRunning;
              private MonObject[] tableauAParcourir;
              private int index;
              private MonJPanel interface;
              //le constructeur
              public LectureThread(MonObject[] tableau,MonJPanel interface){
                       this.tableauAParcourir=tableau;
                       this.wait=false;
                       this.interface=interface
                       this.isRunning=false;
              }
 
              public void run(){
 
                     for(index=0;index!=tableauAParcourir.length;){
 
                          if(!wait){
                                  interface.update(tableauAParcourir[index])
                                  index++;
                          }else{
                                  this.wait();
                          }
                     }
              }
 
             public void pause(){
                     wait=true;
             }
 
             public void stop(){
                     index=0;
                     wait=true;
             }
 
             public void lecture(){
                   if(!isRunning){
                         isRunning=true;
                         this.start();
 
                   }else{
                         this.notify();
                   }
             }
}

voila ca ressemblait a peut pret à ca.

[professeur shadoko]

je n'ai pas lu le code en détail mais deux remarques:
- wait() et notify() en dehors de synchronized(moniteur) donc erreur "not owner"
-tes variables wait et isRunning doivent être volatile!

donc: reprendre complétement la théorie sur les Threads avant de s'attaquer au code.

[dummygreg]

En effet il me faudrait un site sur la théorie de thread sachant que je n'ai jamais rien lu sur le sujet. j'ai fait ça en me laissant inspirer par la javadoc de Thread (ce qui n'est la bonne solution que lorsque l'on sait ou on va).

Je m'étais mis en quêtes d'un tutoriel sur les thread mais j'ai rien trouvé de suffisemment clair pour moi. n'auriez-vous pas une adresse à me conseiller monsieur le professeur?

[professeur shadoko]

bon d'accord c'est en Anglique : http://java.sun.com/docs/books/tutor...ncy/index.html

googler un peu pour trouver un équivalent en français

[aristeas]

lu,

Cours Thread et Communication en Java viennet.developpez.com

@+

[adiGuba]

Il faut bien prendre en compte que tu ne peux pas mettre en pause ou arrêter un thread de l'extérieur : cela peut poser énormément de problème vis-à-vis de l'état du thread.

Il faut simplement lui demander de se mettre en pause ou de s'arrêter.

Cela signifie :

1. Que tu te contentes de modifier une variable (un simple boolean fait amplement l'affaire).
2. Que le code de traitement de ton thread (la méthode run()) doit vérifier à intervalle régulier cette valeur pour traiter la demande (se mettre en pause ou s'arrêter de lui même).

Pour l'arrêt on peut utiliser interrupted() qui a l'avantage d'également arrêter certaines méthodes bloquantes (comme wait() par exemple).
Pour la pause par contre il faut tout gérer soit-même.


Cela donnerait quelque chose comme cela :

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
class ExThread extends Thread {
 
	// Le mot clef 'volatile' indique que la valeur de l'attribut
	// peut être modifié depuis différents threads.
	// Cela interdit donc à la JVM d'optimiser la lecture de la valeur exacte
	// lors de chaque accès à cette variable.
	// Sans ce mot-clef, la JVM pourrait optimiser le code et ne pas détecter
	// des modifications depuis un autre thread :
	private volatile boolean paused;
 
	/**
         * Change l'état 'paused' du thread. Cet état est juste informatif, et doit
         * être repecté par la méthode run() du thread en question.
         */
	public void setPaused(boolean b) {
		if (this.paused != b) {
			synchronized (this) {
				// On se contente de modifier la valeur du boolean :
				this.paused = b;
				if (!this.paused) {
					// Et de notifier le thread lors du passage à 'false'
					this.notifyAll();
				}
			}
		}
	}
 
	/**
         * Indique l'état 'paused' du thread.
         */
	public boolean isPaused() {
		// Accès en lecture : pas besoin de synchronisation
		return this.paused;
	}
 
	/**
         * Indique si le thread est réellement en pause, c'est à dire s'il est dans
         * l'état 'paused' ET dans un wait().
         */
	public boolean isTrulyPaused() {
		return isPaused() && getState() == State.WAITING;
	}
 
	/**
         * Méthode statique qui vérifie l'état du thread courant. Cette méthode doit
         * être appellé à étape régulière par la méthode de traitement du thread...
         * 
         * @throws InterruptedException
         *             Le thread a reçu un interrupt()
         */
	public static void checkCurrentThread() throws InterruptedException {
		// On récupère le thread courant :
		final Thread thread = Thread.currentThread();
		// On vérifie d'abord le status 'interrupted',
		// qui indique si l'on doit terminer le thread ou pas :
		if (thread.isInterrupted()) {
			// On remonte une exception pour stopper le thread :
			throw new InterruptedException("interrupted");
		}
 
		// Puis si le thread est un ExThread :
		if (thread instanceof ExThread) {
			final ExThread exThread = (ExThread) thread;
			// S'il est en état 'paused' :
			if (exThread.isPaused()) {
				synchronized (exThread) {
					// On endors le thread TANT qu'il ne
					// recoit pas de notify() ou d'interruption
					// (la boucle while() permet de se protéger
					// de certain réveils intempestifs assez rare)
					while (exThread.isPaused()) {
						exThread.wait();
					}
				}
 
			}
		}
	}
}

Avec un run() qui ressemblerait à ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
	public void run() {
		try {
			while (true) {
 
				// Traitements 
 
				// Vérification de l'état du thread :
				ExThread.checkCurrentThread();
			}
		} catch (InterruptedException e) {
			// Fin du thread !
		}
	}

De "temps en temps" (à la fin de chaque boucle ici), le thread vérifie son état pour se mettre en pause ou pour stopper tout proprement...


a++

[dummygreg]

merci à tous. je vais me lire ça. je reviendrais à la charge si il y a quelque chose que je comprend pas