Discussion :

[benjaminblazer]

Bonjour,

J'aurais aimé savoir si il était possible d'insérer du code dynamiquement, je m'explique :

J'ai un Timer qui chaque seconde va exécuter du code.
Dans ce dernier, j'aimerais y insérer des lignes de codes uniquement lorsqu'une autre fonction à été appelé.
Cela reviendrais à faire un "if(variable==true){code supplémentaire}" en changeant la valeur de la variable dynamiquement dans d'autres fonctions.
Cependant j'aurais trop de "if" à insérer dans cette boucle qui doit s'exécuter le plus rapidement possible un grand nombre de fois...

J'avais pensé à faire un include et modifier le contenus du fichier dans la fonction mais on ne doit pas pouvoir modifier un fichier qui est executé si ?
Je ne sais pas si j'ai été clair... mais si vous avez des idées ou questions je suis preneur !

Merci d'avance !

[joel.drigo]

Salut,

Je ne pense pas que tu aies besoin d'injecter du code dynamiquement pour faire ce que tu décris. Par là, on entend pouvoir de manière externe, ou interne, insérer du code à chaud, sans avoir nécessairement à recompiler. On peut le faire, de différentes manières :

• en utilisant par exemple du JavaScript, avec Nashorn (interpréteur intégré dans Java 8), ou Rhino avant Java 8. On peut même faire ça avec du Java, avec Beanshell2 par exemple.
• En recompilant à chaud le Java et en utilisant Interface et reflexion (proxies), mais c'est plus compliqué (en particulier avec la gestion des classloaders).

Ensuite, on peut parfaitement gérer dynamiquement ce que fait un Timer, ou autre, en utilisant une technique de délégation. Ce que Java 8 rend plus pratique en particulier avec les expressions-lambdas.
Mais il y a éventuellement plus simple : les services d'exécution (Classe Executors/ExecutorsService). Il te permettront de gérer facilement des tâches uniques, ou répétitives, void ou rendant un résultat, en rendant simple la planification (délai au démarrage, fréquence/période, etc.), l'annulation, la gestion de file d'attente, la répartition/parallélisation, etc. Combiné avec streams et lambdas, on peut écrire un moteur dynamique d'exécution assez pratique à utiliser.

Tout dépend de ce que tu veux faire concrêtement.

[benjaminblazer]

Je ne connais pas tout ça étant donné que je commence en java, je ne connais que les principes grâce au C#, pas les outils/librairies...
Mais je vais essayer de comprendre comment ça marche !

Merci pour les pistes !

ps: pour info je cherche à lancer plusieurs fonctions tous les n tics de timer ( fonctions à exécuter ou non en fonction des actions de l'utilisateur). C'est pour ne pas ralentir que je veux éviter de laisser les tests dans la boucle (Timer)

[joel.drigo]

Voici un exemple de principe avec un ScheduledExecutorService :

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
public class Demo {
 
	public static void main(String[] args) {
 
 
		final ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
 
		ScheduledFuture<?> task1 = executor.scheduleAtFixedRate(()-> System.out.println("s'affiche toutes les trois secondes"), 3, 3, TimeUnit.SECONDS);
 
		pause(2);
 
		AtomicInteger compteur=new AtomicInteger(0);
		executor.scheduleAtFixedRate(compteur::incrementAndGet, 1, 1, TimeUnit.SECONDS);
		ScheduledFuture<?> task2 = executor.scheduleAtFixedRate(()-> System.out.println("s'affiche toutes les secondes"), 1, 1, TimeUnit.SECONDS);
 
		pause(2);
 
		executor.scheduleAtFixedRate(Demo::uneMethode, 500, 500, TimeUnit.MILLISECONDS);
		task1.cancel(true);
 
		pause(2);
		task2.cancel(true);
		executor.scheduleAtFixedRate(()-> System.out.println("s'affiche toutes les quatres secondes"), 0, 4, TimeUnit.SECONDS);
		executor.scheduleAtFixedRate(()-> System.out.println("Au fait, le compteur en est à " + compteur.get()), 0, 10, TimeUnit.SECONDS);
 
 
		pause(30);
 
		executor.shutdownNow();
 
 
		System.out.println("Et on a compté pendant tout ce temps : " + compteur.get());
 
	}
 
	private static void uneMethode() {
		System.out.println("Une tâche qui fait des trucs...");
	}
 
	private static void pause(int i) {
		try {
			Thread.sleep(i*1000);
		} catch (Exception e) { 
			throw new RuntimeException(e);
		}
	}
 
 
}

[benjaminblazer]

Whahouw MERCI !

Tu m'as fais gagné quelques heures !

Ça ne gène pas si il y a trop de thread lancé en même temps ? ( une dizaine qui tournent en même temps avec les pauses )
Ils vont pouvoir s’exécuter dans les temps en se répartissant le temps dédié à chacun ? (dans la mesure où le code n'est pas excessivement lourd)

[joel.drigo]

Ça ne gène pas si il y a trop de thread lancé en même temps ? ( une dizaine qui tournent en même temps avec les pauses )

Forcément, trop de threads va mettre la machine à plat. Mais 10 ce n'est pas grand chose.

Ils vont pouvoir s’exécuter dans les temps en se répartissant le temps dédié à chacun ? (dans la mesure où le code n'est pas excessivement lourd)

Oui, en gros, le service génère des threads au besoin. Le nombre qu'on lui donne à la création est le nombre de threads innocupés qu'il conserve au minimum.
Eventuellement, si tu as des tâches non répétitives, tu peux utiliser plusieurs services, chacun plus adapté au type de tâche (par exemple un newCachedThreadPool() pour exécuter des tâches très courtes très rapidement. Voir la doc pour le détail du fonctionnement de chaque type).
A noter qu'il y a aussi une méthode qui permet de lancer un lot de plusieurs tâches en un appel si tu en as besoin.