Discussion :

[spritrl]

Bonjour,

Je viens demander de l'aide car je n'arrive plus a avancer.

En effet j'étais sur une bonne lancer niveau avancement cependant voici mon problèmes :

Vous pouvez constater à travers cette première partie de code un "Planning" qui, à différents moment de la journée veut faire effectuer des taches en changeant un "int indic" qui a pour valeur de défaut "0".

Lorsque cette variable va changer en : 0, 1, 2 ou 3 des taches sont "censés" s'effectuer.

Cependant voila mon problèmes :

Effectivement lorsque le script va se mettre en route le planning va rediriger vers la condition "if" 0, 1, 2, ou 3; mais lorsque le script va se diriger vers l'une de ces conditions, le "Planning" ne va plus s'actualiser et donc plus rediriger vers une autre condition.

La réponse à mon problème serait donc d'actualiser continuellement mon "Planning" (comme sur Unity avec la fonction "update" ou lors du développement d'app android) sans déranger les taches occupés dans les fonctions "if"

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
 
			// Création table d'heure
			Date Time = new Date();
			DateFormatSymbols monDFS = new DateFormatSymbols();
			SimpleDateFormat dateFormatH = new SimpleDateFormat("HH:mm", monDFS );
			String TimeF= dateFormatH.format(Time);
			System.out.println("Time : "+TimeF);
 
			// Planning 
				switch (TimeF)
				{
				  case "05:30": 
					  indic = 1;
				    break;
				  case "11:30":
					  indic = 3;
				    break;
				  case "14:00":
					  indic = 2;
				    break;
				  case "16:30":
					  indic = 1;
				    break;
				  case "19:00":
					  indic = 2;
				    break;
				  case "21:45":
					  indic = 3;
				    break;
 
				  default:
					  indic = 0;
				}
			}

Action numéro 1 :

Code :

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

1
2
3
4
5
if(indic==1){
 
// Mon code
 
}

Action numéro 2 :

Code :

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

1
2
3
4
5
if(indic==2){
 
// Mon code
 
}

Action numéro 3 :

Code :

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

1
2
3
4
5
if(indic==3){
 
// Mon code
 
}

Si rien ne se passe :

Code :

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

1
2
3
4
5
if(indic==0){
 
// Fonction par défaut
 
}

Merci par avance pour votre aide.

Cordialement.

[joel.drigo]

Salut,

1. C'est quoi ce "planning" ? Un composant Swing ?
2. Et ta variable indic, elle est déclarée où ?
3. C'est quoi ces histoires de scripts ? Ce sont des scripts externes ? En quel langage ?
4. Je ne comprends pas bien cette histoire de mise à jour continuelle :
   
   1. est-ce qu'une sélection de date déclenche un nombre d'actions (la valeur de indic), et l'affichage change en conséquence
   2. ou la sélection de date mets à jour indic et ensuite il y a une tâche de fond qui met à jour je ne sais quoi toutes les n secondes, ou en fonction de résultats produits par les "indic" actions déclenchées (à chaque fois qu'un résultat est produit)
   3. autre ?

Il faudrait en dire un peu plus pour qu'on puisse te répondre.

Par ailleurs, par rapport au code que tu montres, il me semble plus simple et efficace d'utiliser une Map et d'utiliser des LocalTime.

Exemple de principe (je t'ai mis des variantes de la méthode getAction qui permettent d'obtenir l'action en fonction de différents types, tu pourras utiliser celui qui convient le mieux en fonction de la variable qui désigne l'heure) :

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
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
 
public class PlanningExemple {
 
	private static final Map<LocalTime,Integer> PLANNING_ACTIONS = createPlanning();
	private static Map<LocalTime, Integer> createPlanning() {
		Map<LocalTime,Integer> actions = new HashMap<LocalTime,Integer>();
 
		actions.put(LocalTime.of(5, 30), 1);
		actions.put(LocalTime.of(11, 30), 3);
		actions.put(LocalTime.of(14, 0), 2);
		actions.put(LocalTime.of(16, 30), 1);
		actions.put(LocalTime.of(19, 30), 2);
		actions.put(LocalTime.of(21, 45), 3);
 
		return Collections.unmodifiableMap(actions);
	}
	public static int getAction(LocalTime time) {
		return PLANNING_ACTIONS.getOrDefault(time, 0);
	}
 
	public static int getAction(String time) {
		return getAction(LocalTime.parse(time,DateTimeFormatter.ofPattern("HH:mm")));
	}
 
	public static int getAction(int hours, int minutes) {
		return getAction(LocalTime.of(hours, minutes));
	}
 
	public static int getAction(java.util.Date time) {
		return getAction(time.toInstant().atZone(ZoneId.systemDefault()).toLocalTime());
	}
 
	public static void main(String[] args) {
 
		LocalTime localTime = LocalTime.of(19, 30);
 
		int indic = PlanningExemple.getAction(localTime);
 
		System.out.println(localTime + " : " + indic);
 
	}
 
}

[spritrl]

Bonjour,

Merci d'avoir essayé de comprendre mon problème et désolé si je me suis mal expliquer.
Il s'agit d'un BOT qui, à différents moments de la journée doit effectuer des actions (d'ou l'histoire du planning) et c'est ces actions (qui sont sous forme de boucle) qui se trouvent à l'intérieur des "if(indic==x).." .

1 - Ma variable indic, est déclarée au début de mon code et je croyais m'en servir justement comme "indicateur" afin de rediriger mon code vers les actions.
2 - Ces scripts sont comme dit au début : des actions que devra exécuter le BOT.
Ces scripts sont en java et à la suite du planning(mais peuvent être adapter selon la solution trouvée).

Pour ce qui est des mises à jour continuelle:
Oui, la sélection de date mets à jour indic et ensuite il y a une tâche de fond qui exécute des actions.
Et c'est en fonction des résultats produits par "indic" qu'il va s'agir d'actions contenu dans un if(indic==x) ou if(indic==y).

Merci par avance de votre réponse.
Cordialement.

[joel.drigo]

Il s'agit d'un BOT qui, à différents moments de la journée doit effectuer des actions (d'ou l'histoire du planning) et c'est ces actions (qui sont sous forme de boucle) qui se trouvent à l'intérieur des "if(indic==x).." .

Donc, il n'y a pas d'interface graphique, c'est bien ça ? Parce que la solution n'est pas la même s'il y a ou pas.

En gros, si je comprends bien, tu veux pouvoir exécuter un code en fonction de indic sans bloquer la boucle principale (qui traite une date), dans un processus parallèle donc. Sans interface graphique, la solution de base est le thread. Il existe des "extensions" qui permettent de gérer ça (avec des threads) mais plus facilement, comme les services d'exécutions, ou les timers, selon les besoins, ainsi que certaines possibilités des streams pour traiter des collections d'objets avec parallélisation.

1 - Ma variable indic, est déclarée au début de mon code et je croyais m'en servir justement comme "indicateur" afin de rediriger mon code vers les actions.

La question concernait surtout la portée de la variable. Au début du code, ça ne veut pas dire grand chose en Java, un langage objet, à part qu'elle pourrait être déclarée locale à la méthode main, au début de cette méthode. La portée de la variable est important en multi thread, en particulier si plusieurs threads ont accès à cette variable, potentiellement simultanément en particulier.

2 - Ces scripts sont comme dit au début : des actions que devra exécuter le BOT.
Ces scripts sont en java et à la suite du planning(mais peuvent être adapter selon la solution trouvée).

Des méthodes Java donc (il n'y a pas vraiment de script en Java).

Pour ce qui est des mises à jour continuelle:
Oui, la sélection de date mets à jour indic et ensuite il y a une tâche de fond qui exécute des actions.
Et c'est en fonction des résultats produits par "indic" qu'il va s'agir d'actions contenu dans un if(indic==x) ou if(indic==y).

Ce qui n'est pas encore clair pour moi c'est le processus. Surtout qu'un if est exécuté dans une séquence, à un moment déterminé. Ce n'est pas comme si c'était un élément réactif qui réagissait au changement d'une valeur. Tu penses peut-être à une boucle while ? A priori, je pense que tu n'as pas besoin de ces ifs, et le while est potentiellement une mauvaise solution (ou du moins problématique) mais comme je n'ai que très peu d'informations sur le processus, c'est difficile pour moi de voir exactement de ce que tu cherches à faire. On pourrait même peut-être se passer de indic. Dans l'exemple que je t'ai donné avec la map, on pourrait remplacer les Integer par des actions (des objets avec une méthode qui fait l'exécution).

Est-ce que le but est de faire une action particulière à intervalle régulier dont le code varie en fonction de indic ? En résumé, quand l'heure change, l'action change.

Et ces actions, elles font quoi ? Elles tournent en boucle jusqu'à ce qu'on change indic ? Elles tournent en boucle, mais ne font quelque chose que si indic correspond à une certaine valeur, sinon rien. Est-ce qu'elles tournent en boucle, mais seulement pour faire un truc de temps en temps, et le reste du temps ne font rien (ou attende) ? Sinon, si ce ne sont pas des boucles, l'exécution est-elle relativement courte ou plutôt longue ?

A noter que pour l'exécution en parallèle, il est important de prendre en compte l'accès simultané et concurrent des objets par plusieurs processus en même temps. C'est pourquoi une compréhension plus précise de ta problématique me permettra de te suggérer des solutions plus ou moins adaptées, efficaces, performantes et simples d'emploi.

[spritrl]

Aucunes interface graphique c'est ça,
Comment pourrais je procédé avec des thread car :
Oui, le but est d’effectuer une action particulière à intervalle régulier.
Oui, les actions tournent en boucle jusqu'à ce qu'on change indic
Et donc en gros : quand l'heure change, l'action change

[spritrl]

J'ai essayé les threads mais sans succès..
Lorsqu'une action se lance le planning cesse de s'exécuter..
Ou est l'erreur?

Main.java :

Code :

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

1
2
3
4
5
6
 
public class main {
	public static void main(String[] args) {
		 new Thread(new Planning()).start();
	}
}

Planning.java

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
public class Planning implements Runnable {
 
 
	public void run() {
 
			Thread Action1 = new Thread(new Action1());
			Thread Action2 = new Thread(new Action2());
			Thread ActionDefaut = new Thread(new ActionDefaut());     
 
							// Création table d'heure
							Date Time = new Date();
							DateFormatSymbols monDFS = new DateFormatSymbols();
							SimpleDateFormat dateFormatH = new SimpleDateFormat("HH:mm", monDFS );
							String TimeF= dateFormatH.format(Time);
							System.out.println("Time : "+TimeF);
 
							// Planning 
							switch (TimeF)
								{
								  case "05:30": 
									  Action1.start();
									  Action2.interrupt();
								    break;
								  case "11:30":
									  Action2.start();
									  Action1.interrupt();
								    break;
								  case "14:00":
									  Action1.start();
									  Action2.interrupt();
								    break;
								  case "16:30":
									  Action2.start();
									  Action1.interrupt();
								    break;
								  case "19:00":
									  Action1.start();
									  Action2.interrupt();
								    break;
								  case "21:45":
									  Action1();
								    break;
 
								  default:
									  ActionDefaut.start();
								}
				}	
		    }

[joel.drigo]

Oui, le but est d’effectuer une action particulière à intervalle régulier.
Oui, les actions tournent en boucle

Ceci est contradictoire : soit une action s'exécute à intervalle régulier, soit elle tourne en boucle.

Oui, le but est d’effectuer une action particulière à intervalle régulier.

Oui, les actions tournent en boucle jusqu'à ce qu'on change indic

Ce serait donc plus simple d'utiliser un type d'action qu'un int/Integer. En tout cas, plus direct.

Pour faire l'action, on va utiliser l'interface Runnable (pour le principe, ce sera peut-être à adapter si ton action est paramétrée).

En supposant que l'action s'exécute à intervalle régulier, on pourrait utiliser un java.util.Timer, qui permet d'exécuter une tâche toutes les n millisecondes.

Pour gérer la tâche à exécuter, on va faire une classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ActionTimerTask extends TimerTask {
 
		private volatile Runnable runnable;
 
		public void setAction(Runnable runnable) {
			this.runnable=runnable;
		}
 
		@Override
		public void run() {
			if ( runnable!=null ) runnable.run();
		}
 
	}

Pour créer le timer et exécuter la tâche, au début de la méthode main :

Code :

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

1
2
3
4
ActionTimerTask task = new ActionTimerTask();
 
Timer timer = new Timer();
timer.schedule(task, 1000); // exécution toutes les 1 secondes (à adapter)

Donc en changeant la map comme ça :

Code :

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

	private static final Map<LocalTime,Runnable> PLANNING_ACTIONS = createPlanning();

Et pour enregistrer l'action pour une date :

Code :

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

1
2
3
4
5
actions.put(LocalTime.of(5, 30), ()-> {
   // ici le code de l'action
   // par exemple :
   System.out.println("Action 5:30");
});

Il faut modifier la/les méthode/s :

Code :

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

1
2
3
public static Runnable getAction(LocalTime time) {
		return PLANNING_ACTIONS.get(time);
	}

Ensuite, il ne te restera plus qu'à faire :

Code :

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

task.setAction( getAction(date) );

Et l'action exécutée toutes les secondes changera.

[joel.drigo]

Main.java :

Code :

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

1
2
3
4
5
6
 
public class main {
	public static void main(String[] args) {
		 new Thread(new Planning()).start();
	}
}

Ça, ça ne sert à rien : un programme a forcément son propre thread, le thread principal. Ne faire que lancer un autre thread n'a aucun intérêt, autant utiliser le thread principal.

Code :

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

1
2
3
 
Action1.start();
Action2.interrupt();

A supposer que l'état interrupt est bien géré pour arrêter le thread, ce que ce code fait c'est démarré l'action et immédiatement l'arrêter... donc ça ne sert à rien non plus, ou pas à grand chose en tout cas.
Ce qu'il faudrait éventuellemnt, c'est bien le start, mais appeler une méthode d'arrêt sur le dernier thread d'action lancé, ce qui t'oblige déjà à le mémoriser. Ensuite, il faut savoir qu'un thread ne peut s'exécuter qu'une fois, donc il faudra le réinstancier en plus d'appeler la méthode start(). Et il faudra bien écrire du code pour gérer l'arrêt : l'appel de interrupt() ne suffit pas (ça ne fait que changer un état, que certaines méthodes peuvent gérer pour lancer une exception InterruptedException (comme Thread.sleep() par exemple).

Par ailleurs, ce que fait la méthode run de ton thread Planning, c'est instancier trois objets de classe Thread et ensuite sélectionner une action à exécuter en fonction d'une date. La date étant la date actuelle (new Date()), à part si l'heure correspond à l'un des case, ça va lancer le thread ActionDefault, ce qui est le plus probable (vu l'heure à laquelle tu fais le test). Et si l'heure correspond, ça lance l'action correspondant, ça appelle interrupt, et ça fait plus rien d'autre.
Comme je ne sais pas ce que font tes actions, je ne peux pas savoir ce qu'il se produit exactement avec l'appel de start.

PS : pour un débutant, ce n'est très grave de ne pas utiliser les conventions Java (lowerCamelCase pour les variables, et UpperCamelCase pour les classes), mais, pitié, ne pas utiliser des noms de variables pour lesquelles il existe déjà une classe qui a le même nom !

[spritrl]

Merci car je crois que tu as compris ce que je voulais et que je pense que tu as trouvé la solution.
Maintenant deux problèmes
1 : j'ai une migraine
2 : je n'ai pas compris comment placer ton code... Le niveau n'est pas le même je pense, pourrais tu me donner ce que tu as écrit sur ta class de test.

Merci.

[joel.drigo]

2 : je n'ai pas compris comment placer ton code...

Voici un exemple de principe...

Donc des classes actions, ce que tu as dû faire dans ton essai avec thread. Moi j'ai mis juste un System.out.println().

Code :

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

1
2
3
4
5
6
7
8
public class ActionDefault implements Runnable {
 
	@Override
	public void run() {
		System.out.println("Action default");
	}
 
}

Code :

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

1
2
3
4
5
6
7
8
public class Action1 implements Runnable {
 
	@Override
	public void run() {
		System.out.println("Action 1");
	}
 
}

Je ne mets pas Action2 et Action3, c'est pareil sauf le texte qui change...

La classe qui gère planning, timer, association heure/action et tout le toutim...

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
import java.time.LocalTime;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
 
public class Planning {
 
	private static final ActionDefault actionDefault = new ActionDefault(); // l'action par défaut
 
	private static final long DELAY = 1000; // exécution toutes les 1 secondes
 
	private static Timer timer; // le time pour exécuter toutes les DELAY ms
	private static ActionTimerTask task; // la tâche à exécuter par le timer
 
	// la map qui associe heures et actions
	private static final Map<LocalTime,Runnable> PLANNING_ACTIONS = createPlanning();	
	private static Map<LocalTime, Runnable> createPlanning() {
		Map<LocalTime,Runnable> actions = new HashMap<LocalTime,Runnable>();
 
                // je crée trois actions		
		Action1 action1 = new Action1();
		Action2 action2 = new Action2();
		Action3 action3 = new Action3();
 
                // j'associer les actions avec les heures
		actions.put(LocalTime.of(5, 30), action1);
		actions.put(LocalTime.of(11, 30), action3);
		actions.put(LocalTime.of(14, 0), action2);
		actions.put(LocalTime.of(16, 30), action1);
		actions.put(LocalTime.of(19, 30), action2);
		actions.put(LocalTime.of(21, 45), action3);
 
		return Collections.unmodifiableMap(actions);
	}
 
	private static Runnable getAction(LocalTime time) {
                // retourne l'action associée à l'heure, et s'il y en a pas actionDefault
		return PLANNING_ACTIONS.getOrDefault(time, actionDefault);
	}
 
	/**
         * Pour démarrer
         */
	public static synchronized void start() {
 
		if ( timer==null ) {
			task = new ActionTimerTask();
 
			timer = new Timer();
			timer.schedule(task, DELAY, DELAY);
		}
 
	}
 
	/**
         * Pour arrêter
         */
	public static synchronized void stop() {
		if ( timer!=null ) {
			timer.cancel();
			timer=null;
		}
	}
 
	/**
         * Pour affectr une neure et donc changer l'action. ça démarre le timer automatiquement si nécessaire
         * @param time
         */
	public static void setTime(LocalTime time) {
		start();
		task.setAction(getAction(time));
	}
 
	private static class ActionTimerTask extends TimerTask {
 
		private volatile Runnable runtime = actionDefault;
 
		public ActionTimerTask() {
		}
 
		public void setAction(Runnable runtime) {
			this.runtime=runtime;
		}
 
		@Override
		public void run() {
			if ( runtime!=null ) runtime.run();
		}
 
	}
 
}

Pour faire tourner le poc, j'ai fait une petit UI :

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
import java.awt.Component;
import java.awt.event.WindowAdapter;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
 
import javax.swing.DefaultListCellRenderer;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
 
public class Demo {
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		// la liste des choix
		LocalTime[] times = {
				LocalTime.of(5, 30),
				LocalTime.of(11, 30),
				LocalTime.of(12, 45), // une heure sans association
				LocalTime.of(14, 00),
				LocalTime.of(16, 30),
				LocalTime.of(19, 30),
				LocalTime.of(21, 45),
				null
		};
 
		JList<LocalTime> list = new JList<>(times);
		list.setCellRenderer(new DefaultListCellRenderer() {
			@Override
			public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected,
					boolean cellHasFocus) {
				if ( value instanceof LocalTime ) {
					value = ((LocalTime)value).format(DateTimeFormatter.ofPattern("HH:mm"));
				}
				else {
					value = "Default";
				}
 				return super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
			}
		});
 
		list.setSelectedIndex(times.length-1);
		// ici on écoute les changements de sélection
		list.addListSelectionListener(new ListSelectionListener() {
 
			@Override
			public void valueChanged(ListSelectionEvent e) {
				if ( !e.getValueIsAdjusting() ) {
					// on appelle setTime avec la valeur sélectionnée dans la liste
					Planning.setTime(list.getSelectedValue());
				}
			}
		});
 
		frame.add(list);
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
		frame.addWindowListener( new WindowAdapter() {
			public void windowClosed(java.awt.event.WindowEvent e) {
				Planning.stop();
			}
		});
		Planning.start();
 
	}
 
}

[spritrl]

Cela marche dans votre cas

[spritrl]

Cela marche dans votre cas mais regardez a quoi doivent ressembler mes actions :
Il y a des boucles dedans et en plus elles sont dépendantes de d'autres class.
Donc une fois la boucle lancer, elle n'est pas arrête par le thread et continue a tourner.

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
package com.ghost.main;
 
import java.io.IOException;
 
import org.apache.http.client.ClientProtocolException;
 
public class Action1 implements Runnable {
	public static void main(String[] args) throws ClientProtocolException, IOException, InterruptedException {
		for(int i = 1; i <= 99990; i++)
		{
		try{Thread.sleep(2000);}catch(InterruptedException e){System.out.println(e);}
		  System.out.println("Voici la ligne "+i);
		  try {
			  System.out.println("Autre");
		  }catch(IndexOutOfBoundsException e) {
				System.out.println(".....");
			}
			catch(NullPointerException e) {
				System.out.println("....");
			}
		  }
		}
	@Override
	public void run() {
		try {
			main(null);
		} catch (IOException | InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}
	}

[joel.drigo]

Déjà, à quoi sert la méthode main, puisqu'elle est appelée sans paramètre dans la méthode run ? Tu peux déjà la supprimer et déplacer le code dans run.

Ensuite, il y a une boucle, avec attente. Ceci donc effectivement pose problème (c'est pour ça que je t'avais demandé si c'était une boucle ou pas, pour savoir !). Cela pose plusieurs problème en fait.

Est-ce vraiment qu'il y a besoin de traiter des lignes indexées et y'en a t-il vraiment 99990 ? Ou ce chiffre est bidon histoire de traiter "beaucoup" de lignes... (ce que je serais tenté de croire vu le catch d'ArrayIndexOfBoundException (c'est quand même bien foireux de traiter 99990 éléments dans un tableau ou une liste où il y'en a que deux, et se taper 99988 exceptions ! Par ailleurs, les index en Java c'est de 0 à n-1, et ce n'est par hasard, ça simplifie pas mal de chose)
S'il s'agit de traiter des trucs les uns après les autres, ou de traiter le même truc, faire :

Code pseudocode :

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

1
2
3
4
5
 
pour tous les trucs à traiter
   je traite 
   j'attends x ms
fin pour

ou faire

Code pseudocode :

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

1
2
3
4
5
 
tous les x ms faire
   s'il y a quelque chose à traiter
        je traite le prochain truc à traiter
fin

c'est la même chose, sauf que dans le second cas, on utilise un timer et c'est plus simple, alors que dans le premier cas, on fait une boucle dans un thread avec un booléen volatile pour gérer l'arrêt (sur changement d'action), c'est plus compliqué. Éventuellement, on peut suspendre le timer lorsqu'on arrive à la fin.

Quid des machins non traités quand on change d'action ? En particulier, quid si on change d'heure mais ça change pas d'action ? Et, d'ailleurs c'est quoi ces machins à traiter dans la boucle ? C'est fixe ? Ou c'est une file (ou une pile) ? Chaque action à sa propre collection de machins, ou elle est partagée ? Pourquoi un temps d'attente entre chaque traitement ?

[spritrl]

Voila une action avant les 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
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
99
100
101
102
103
104
public class Main {
	private String username;
	private ArrayList<String> blacklist = new ArrayList<String>();
	private ArrayList<String> userF = new ArrayList<String>();
 
	public void init() {
		BasicConfigurator.configure();
		Logger.getRootLogger().setLevel(Level.OFF);
	}
 
	public static void main(String[] args) throws ClientProtocolException, IOException, InterruptedException {
		Main main = new Main();
		main.init();
		Wini ini = new Wini(new File("options.ini"));
		main.username = ini.fetch("Login", "Name");
		String pass = ini.fetch("Login", "Password");
		System.out.println("Logging in as: " + main.username);
		bot.setup();
		bot.login();
 
		if (bot.isLoggedIn()) {
			main.readBlacklist();
			main.readuserF();
			int indic = 0;
			int max = 600;
			FileWriter writer = new FileWriter("userF.txt", true);
			System.out.println("Set up");
 
			botGetResult botResult = bot
					.sendRequest(new botFRequest(bot.getUserId()));
 
			System.out.println("Set up : OK !");
			int user = 45818965;
 
			botFeedResult userFeed = bot
					.sendRequest(new botUserFeedRequest(user));	
			botFeedItem item = userFeed.getItems().get(0); 
			String maxId=null;
			String UFfinalResult = String.valueOf(item.getPk());
			long UFlong = Long.valueOf(UFfinalResult);
 
			botGetMediaResult MediaeResult = bot
					.sendRequest(new botMediaRequest(UFlong));
			for(botUserSummary Persx : botResult.getUsers()) {
				System.out.println(Persx.getPk());
			}
 
			botGetMediaComResult comResult = bot
						.sendRequest(new botGetMediaComRequest(UFfinalResult, maxId));
 
 
			for (botComment com : comResult.getCom()) {
				try{Thread.sleep(1000);}catch(InterruptedException e){System.out.println(e);}
 
 
				boolean userFblacklisted = main.userF.contains(comment.get().geName());
				String toPrint = comment.getUser().getUsername();
				toPrint += userFblacklisted ? " - a deja" : "";
				if (!userFblacklisted) {
					writer.write(comment.getUser().getName()+"\n");
					bot.sendRequest(new botFRequest(com.get().getPk()));
					toPrint += "par COMM'";
				}
				System.out.println(toPrint);
				}
				maxId=comResult.getNext_max_id();
				for(botUserSummary Persx : LResult.getName()) {
					try{Thread.sleep(1000);}catch(InterruptedException e){System.out.println(e);}
					boolean userFblacklisted = main.userF.contains(Persx.getName());
					String toPrintL = Persx.getUsername();
					toPrintL += userFblacklisted ? " - a deja" : "";
					if (!userFblacklisted) {
						writer.write(Persx.getName()+"\n");
						bot.sendRequest(new botFRequest(Persx.getPk()));
						toPrintL += "LIKE";
					}
					System.out.println(toPrintL);
					}
				writer.close();
				indic = 0;
				}
 
		}
 
 
 
	public void readBlacklist() throws FileNotFoundException, IOException {
		try (BufferedReader br = new BufferedReader(new FileReader("blacklist.txt"))) {
			String line;
			while ((line = br.readLine()) != null) {
				blacklist.add(line);
			}
		}
	}
 
	public void readuserF() throws FileNotFoundException, IOException {
		try (BufferedReader br = new BufferedReader(new FileReader("userF.txt"))) {
			String line;
			while ((line = br.readLine()) != null) {
				userF.add(line);
			}
		}
	}
}

[spritrl]

Si je fais comme vous me dites lorsque je veux placer : "(String[] args) throws ClientProtocolException, IOException, InterruptedException" après mon "public void run()"
il me demande de générer :

Code :

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

1
2
3
4
5
6
 
@Override
	public void run() {
		// TODO Auto-generated method stub
 
	}

C'est pourquoi j'avais effectué :

Code :

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

1
2
3
4
5
6
7
8
9
 
public void run() {
		try {
			main(null);
		} catch (IOException | InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		}

[spritrl]

Est-ce vraiment qu'il y a besoin de traiter des lignes indexées et y'en a t-il vraiment 99990 ? Ou ce chiffre est bidon histoire de traiter "beaucoup" de lignes... (ce que je serais tenté de croire vu le catch d'ArrayIndexOfBoundException (c'est quand même bien foireux de traiter 99990 éléments dans un tableau ou une liste où il y'en a que deux, et se taper 99988 exceptions

Non, j'ai choisi juste un grand nombre pour vous montrer que ce que vous m'aviez montré ne fonctionné pas dans mon cas.

c'est quoi ces machins à traiter dans la boucle ? C'est fixe ? Ou c'est une file (ou une pile) ? Chaque action à sa propre collection de machins, ou elle est partagée ? Pourquoi un temps d'attente entre chaque traitement ?

Oui, il s'agit d'une pile, ou chaque action a sa propre collection de machins et il y a un temps d'attente entre chaque traitement pour pas se faire "expulser" du serveur.

[joel.drigo]

Je résume pour que ça soit bien clair (pour moi, et pour toi, pour confirmer, ou infirmer) :

1. Tu as une liste d'actions
   
   1. Chaque action traite une liste d'éléments (chargés depuis un fichier) et fait un traitement pour chacun de ces éléments, traitement qui comprend une requête (ou plusieurs) à un serveur, dont les résultats peuvent servir en entrée d'autres requêtes.
      Première remarque (j'ai posé la question mais je n'ai pas vu la réponse) : je suppose que tous les éléments doivent être traités, jusqu'au bout, si le serveur répond (une autre problématique à gérer éventuellement par ailleurs). Donc déjà, à priori, les actions ne devraient pas être interrompues. Ou en tout cas, pas recommencées à 0 (sinon on va traiter les n premiers plusieurs fois, et on risque de ne pas traiter les derniers de la liste)
   2. En fonction de l'heure, on doit exécuter une certaine action
2. Tu dis qu'il y a une pile mais je ne vois pas où. Mais peu importe.

Ensuite, au sujet du run qui appelle le main, ce que je veux dire c'est que la méthode main n'a d'intérêt que pour démarrer un programme.
Si tu écrits :

Code :

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

1
2
3
4
5
6
7
8
public class Machin implements Runnable {
    public static void main(String[] args) {
          // du code
    }
    public void run() {
       main(null);
    }
}

Tu peux aussi bien écrire :

Code :

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

1
2
3
4
5
public class Machin implements Runnable {
    public void run() {
          // du code
    }
}

Et puis, dans le cas général, main étant static, le risque est d'avoir des états static donc d'avoir plusieurs instances de Machin qui se mélangent les pinceaux.
Pour être précis, la classe Machin pourrait être :

Code :

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

1
2
3
4
5
6
7
8
9
public class Machin implements Runnable {
 
    public Machin() {
          init(); 
    }
    public void run() {
          // du code
    }
}

Éventuellement, avec une partie static, en particulier si les fichiers ne sont pas censés changer au cours d'une exécution (ce qui poserait d'autres problèmes au moment du chargement par ailleurs), voire à part (initialisé au démarrage du programme et partagées entre actions).

Ensuite, au lieu de découper en action qui font des requêtes, je séparerais la partie création des requêtes et la partie exécution des requêtes.

1. Une partie qui programme des actions pour les exécuter à une heure précise. Et je suppose que c'est tous les jours, non ?
   Il existe des API externes pour faire ce genre de chose, mais on peut utiliser un SchedulerExecutorService en calculant le délai correspondant à la date de programmation, et en reprogrammant l'action à chaque fois qu'elle s'exécute.
2. Des actions qui ne font que parcourir les listes de machins et fabriquer des requêtes (ou des suites de requêtes) pour les mettre dans une file (FIFO). Des producteurs donc. Des actions qui s'exécutent dans un thread, ou chaque action dans son propre thread. Dans l'exemple suivant j'utilise un pool de threads, ça limite le nombre de threads, mais ça permet l'exécution de plusieurs actions en simultané (un max de requête correspondant au nombre de threads dans le pool)
3. Un consommateur qui consomme la file pour lancer les requêtes à son rythme (dans son propre thread).

Le temps d'exécution des actions n'est pas impacté par l'exécution des requêtes et elles se déroulent jusqu'au bout sans être interrompues. Au pire, on risque un agrandissement de la file de requêtes qu'il faudra étudier le cas échéant. Mais au moins, les deux problématiques sont séparées et donc traitables de façon isolée.

Voici un POC. Même si ça ne correspond pas exactement à ce que tu recherches (il reste encore des parties non claires pour moi), tu devrais avoir là un bon exemple ce que tu peux faire (avec le précédent), sans chercher à faire tout en thread. Tu peux aussi adapter les interfaces (utiliser autre chose que Runnable).

Donc le consommateur :

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
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
 
public class Consumer {
 
	private final BlockingQueue<Runnable> queue; // une file d'attente, synchronisée et thread-safe
	private volatile boolean running;
	private final Runnable queueConsumer; // pour le thread de consomamtion
	private Thread thread;
 
	/**
         * Créer un consommateur 
         * @param initialCapacity capacité initiale de la file
         * @param delay délai en ms entre chaque exécution
         */
	public Consumer(int initialCapacity, long delay) {
		queue = new ArrayBlockingQueue<>(initialCapacity);
		queueConsumer = ()-> {
			running = true;
            while(running){
            	try {
                    Runnable runnable = queue.take();
				    try {
				    	runnable.run();
				    }
				    catch(Throwable e) {
				    	// logging...
				    }
				    Thread.sleep(delay);
				} catch (InterruptedException e) {
					running=false;
				}
            }
		};
		start();
	}
 
	public boolean addRunnable(Runnable runnable) {
		if ( runnable!=null ) {
			try {
				queue.put(runnable);
				return true;
			} catch (InterruptedException e) {
			}
		}
		return false;
	}
 
	/**
         * Retourne le nombre de runnable en attente d'exécution
         * @return
         */
	public int getPending() {
		return queue.size();
	}
 
	/**
         * Démarre le consommateur
         */
	public synchronized void start() {
		if ( !running ) {
			(thread = new Thread(queueConsumer)).start();
		}
	}
 
	/**
         * Arrête le consommateur
         */
	public synchronized void stop() {
		if ( running ) {
			if ( thread!=null ) {
				thread.interrupt();
				thread=null;
			}
			running = false;
		}
	}
 
}

Le scheduler (le programmateur) :

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
public class ActionScheduler {
 
	private ScheduledExecutorService executor;
 
	/**
         * 
         * @param corePoolSize nombre de threads pour exécuter les actions
         */
	public ActionScheduler(int corePoolSize) {
		executor = Executors.newScheduledThreadPool(corePoolSize);
	}
 
	public void shutdown() {
		executor.shutdown();
	}
 
	public void shutdownNow() {
		executor.shutdownNow();
	}
 
	/**
         * Enregistre l'action pour s'éxécuter tous les jours à l'heure spécifiée
         * @param localTime
         * @param action
         */
	public void register(LocalTime localTime, Runnable action) {
		LocalDateTime now = LocalDateTime.now();
		LocalDateTime next = now.with(localTime);
        if( now.compareTo(next) > 0) {
        	next = next.plusDays(1);
		}
		startExecutionAt(next, action);
    }
 
	private void startExecutionAt(LocalDateTime time, Runnable action) {
        long delay = computeNextDelay(time);
        if ( delay==0 ) System.exit(0);
        executor.schedule(new Runnable(){
 
            @Override
            public void run() {
                startExecutionAt(time.plusDays(1), action);
                action.run();
            }
 
        }, delay, TimeUnit.SECONDS);
	}
 
	/**
         * Calcule le délai pour l'éxécution (en secondes) à l'heure voulue
         * @param next
         * @return
         */
	private long computeNextDelay(LocalDateTime next) {
        LocalDateTime now = LocalDateTime.now();
        Duration duration = Duration.between(now, next);
        return duration.getSeconds();
    }
 
}

Une démo de principe :

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
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
 
public class Demo2 {
 
	public static void main(String[] args) {
		Consumer consumer = new Consumer(10000, 2000);
		ActionScheduler runner = new ActionScheduler(5);
 
		// enregistre tes actions comme ça (on passe le consumer au constructeur pour programmer l'exécution des requêtes
		// runner.register(LocalTime.of(5, 30), new Action1(consumer));
 
		// pour test...
		LocalTime time1 = LocalTime.now().plus(5, ChronoUnit.SECONDS); // démarre dans 5 secondes (et recommencera demain à la même heure/minute/seconde
		LocalTime time2 = LocalTime.now().plus(6, ChronoUnit.SECONDS); // démarre dans 6 secondes (et recommencera demain à la même heure/minute/seconde
 
		runner.register(time1, ()-> {
			for(int i=0; i<10; i++) {
				final int fi=i;
				// ici j'enregistre une action qui ne fait qu'écrire en console
				consumer.addRunnable(new Runnable() {
 
					@Override
					public void run() {
						System.out.println("Action 1 / " + fi);
					}
				});
				try {
					Thread.sleep(500); // juste pour que les deux action 1 et 2 se déroulent en même temps (se chevauchent)
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
		runner.register(time2, ()-> {
			for(int i=0; i<10; i++) {
				final int fi=i;
				// ici j'enregistre une action qui ne fait qu'écrire en console
				consumer.addRunnable(new Runnable() {
 
					@Override
					public void run() {
						System.out.println("Action 2 / " + fi);
					}
				});
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
 
	}
 
}

[spritrl]

Chaque action traite une liste d'éléments (chargés depuis un fichier) et fait un traitement pour chacun de ces éléments, traitement qui comprend une requête (ou plusieurs) à un serveur, dont les résultats peuvent servir en entrée d'autres requêtes.

Chaque action traite une liste d'éléments chargés depuis une (ou plusieurs) requêtes que j'envoie à un serveur (que je ne contrôle pas) à travers les "sendRequest" et que je reçois par les "Result".

Première remarque (j'ai posé la question mais je n'ai pas vu la réponse) : je suppose que tous les éléments doivent être traités, jusqu'au bout, si le serveur répond (une autre problématique à gérer éventuellement par ailleurs). Donc déjà, à priori, les actions ne devraient pas être interrompues. Ou en tout cas, pas recommencées à 0 (sinon on va traiter les n premiers plusieurs fois, et on risque de ne pas traiter les derniers de la liste)[*]En fonction de l'heure, on doit exécuter une certaine action[/LIST][*]Tu dis qu'il y a une pile mais je ne vois pas où. Mais peu importe.[/LIST]

Tout d'abord, non, tout les éléments ne sont pas obligés d'être traités car lors de la prochaine session de cette action des nouveaux éléments arriveront. C'est a dire qu'interrompre l'action pendant qu'elle est en cours d'exécution ne posera aucuns problèmes !

Ensuite, au sujet du run qui appelle le main, ce que je veux dire c'est que la méthode main n'a d'intérêt que pour démarrer un programme.
Si tu écrits :

Code :

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

1
2
3
4
5
6
7
8
public class Machin implements Runnable {
    public static void main(String[] args) {
          // du code
    }
    public void run() {
       main(null);
    }
}

Tu peux aussi bien écrire :

Code :

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

1
2
3
4
5
public class Machin implements Runnable {
    public void run() {
          // du code
    }
}

Non ! Car mon action doit obligatoirement contenir "(String[] args)" qui n'est a priori pas compatible avec la méthode "run".

[LIST=1][*]Une partie qui programme des actions pour les exécuter à une heure précise. Et je suppose que c'est tous les jours, non ?

Oui, j'ai acheté un raspberry spécialement dédié.

Dans l'exemple suivant j'utilise un pool de threads, ça limite le nombre de threads, mais ça permet l'exécution de plusieurs actions en simultané (un max de requête correspondant au nombre de threads dans le pool)

Je ne veux pas l’exécution de taches simultané justement, je cherche a ce que mes actions soit séparés ! D’où le "planning" !

Ce qu'il me faudrait ce serait exactement la même chose qu'hier mais ou lorsqu'une nouvelle action se lance celle qui était en exécution s’arrête.
Je n'ai pas envie de vous dérangez, si cela vous surcharge plus qu'autre chose même si oui comme je vous ai dit j'ai un minimum investi dans ce projet.

[joel.drigo]

Chaque action traite une liste d'éléments chargés depuis une (ou plusieurs) requêtes que j'envoie à un serveur (que je ne contrôle pas) à travers les "sendRequest" et que je reçois par les "Result".

J'avais compris ça. C'est une des rares choses qui sont parfaitement claires.

Tout d'abord, non, tout les éléments ne sont pas obligés d'être traités car lors de la prochaine session de cette action des nouveaux éléments arriveront. C'est a dire qu'interrompre l'action pendant qu'elle est en cours d'exécution ne posera aucuns problèmes !

Ok. Ça aussi c'est clair maintenant.

Non ! Car mon action doit obligatoirement contenir "(String[] args)" qui n'est a priori pas compatible avec la méthode "run".

Non, c'est n'importe quoi. Déjà ça ne veut rien dire qu'une action doivent contenir "(String[] args)". Ensuite, si tu veux dire par là qu'il faut une méthode avec ce type d'arguments, je veux bien, mais dans l'exemple que tu me montres, tu passes null en valeur pour le String[] args, donc ça ne sert à rien. Et si tu as vraiment besoin de paramètres (il fallait le dire au moins), on peut utiliser une autre interface que Runnable (ce n'était qu'un exemple de principe). On peut même faire sa propre interface. Ce n'est pas tant que le fait que tu aies une méthode avec un argument String[], c'est le fait que ce soit une méthode static. Et si ça pouvait être des paramètres typés, ou du String...args, ça aurait plus de sens. Là tu me montres une méthode qui est censé être utilisée pour démarrer un programme, ce qui n'est pas normal.

Oui, j'ai acheté un raspberry spécialement dédié.

Je ne vois pas trop le rapport avec le hardware. On parle de software ici.

Je ne veux pas l’exécution de taches simultané justement, je cherche a ce que mes actions soit séparés ! D’où le "planning" !

C'est ce que j'avais cru comprendre, que les tâches soient simultanées. Que les actions soient séparées, j'avais bien compris, et c'est le cas de tous mes exemples, et l'un n'empêche pas l'autre.

Ce qu'il me faudrait ce serait exactement la même chose qu'hier mais ou lorsqu'une nouvelle action se lance celle qui était en exécution s’arrête.

C'est bien le cas de mon exemple de classe Planning. Seulement, l'action dans mon exemple ne fait pas de boucle.
Mais comme je le disais, au lieu d'une boucle qui fait un truc en attendant 2 secondes entre chaque, on peut faire une action qui s'exécute toutes les 2 secondes, en traitant à chaque fois un nouvel élément dans une liste (en incrémentant un index à chaque fois). Cependant, ce sera plus simple de faire une action qui fait une boucle dans ton cas. Et plus de timer.

Si tu fais une action comme ça, par exemple :

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
public class Action1 implements Runnable {
 
	private List<String> list = new ArrayList<>();
 
	@Override
	public void run() {
		for(int i=0; !Thread.currentThread().isInterrupted() && i<list.size(); i++) {
			// traitement de list.get(i);
			try {
				Thread.sleep(2000);
			}
			catch(InterruptedException e) {
                                   break;
			}
		}
        }

tu pourras changer ton action :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
private Thread runner;
void setAction(Runnable runnable) {
        if ( runner != null ) {
             // on arrête l'action précédente
             runner.interrupt();
        }
        runner = runnable==null?null:new Thread(runnable);
        if ( runner != null ) {
             // on démarre l'action 
             runner.start();
        } 
}

Toutefois il faut se méfier du // traitement de list.get(i);, car s'il s'agit de faire différentes requêtes, cela peut prendre du temps, et ça ne sera pas interrompu automatiquement (sauf pour des méthodes qui gèrent une InterruptedException) : c'est à toi le gérer, éventuellement en testant avant chaque requête l'état interrupt).

En intégrant ça dans Planning, ça donnerait :

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
public class Planning {
 
	private static final ActionDefault actionDefault = new ActionDefault(); // l'action par défaut
 
	// la map qui associe heures et actions
	private static final Map<LocalTime,Runnable> PLANNING_ACTIONS = createPlanning();	
	private static Map<LocalTime, Runnable> createPlanning() {
		Map<LocalTime,Runnable> actions = new HashMap<LocalTime,Runnable>();
 
		Action1 action1 = new Action1();
		Action2 action2 = new Action2();
		Action3 action3 = new Action3();
 
		actions.put(LocalTime.of(5, 30), action1);
		actions.put(LocalTime.of(11, 30), action3);
		actions.put(LocalTime.of(14, 0), action2);
		actions.put(LocalTime.of(16, 30), action1);
		actions.put(LocalTime.of(19, 30), action2);
		actions.put(LocalTime.of(21, 45), action3);
 
		return Collections.unmodifiableMap(actions);
	}
 
	private static Runnable getAction(LocalTime time) {
		return PLANNING_ACTIONS.getOrDefault(time, actionDefault);
	}
 
	/**
         * Pour arrêter
         */
	public static synchronized void stop() {
		setAction(null);
	}
 
	public static void setTime(LocalTime time) {
		setAction(getAction(time));
	}
	private static Thread runner;
	private static synchronized void setAction(Runnable runnable) {
	        if ( runner != null ) {
	             // on arrête l'action précédente
	             runner.interrupt();
	        }
	        runner = runnable==null?null:new Thread(runnable);
	        if ( runner != null ) {
	             // on démarre l'action 
	             runner.start();
	        } 
	}
 
}

Et pour tester avec Demo :

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
public class Action1 implements Runnable {
 
	@Override
	public void run() {
		for(int i=0; !Thread.currentThread().isInterrupted() && i<10000; i++) {
			System.out.println("Action 1 / " + i);
			try {
				Thread.sleep(500);
			}
			catch(InterruptedException e) {
                                   break;
			}
		}
	}
 
}

avec les autres actions sous la même forme

[spritrl]

Est-ce qu'il aurait été possible de lancer une JFrame pour chaque action (default, 1, 2, 3) et que celle-ci contienne mon action ?
Et que lorsque la JFrame se fermerait, l'action se couperait aussi car elle serait contenue dans la JFrame.
Cela servirais à ne pas ajouter de thread dans mon action.

Merci par avance de votre réponse.