Discussion :

[Emcy]

bonjour,

j'ai un bouton qui lance un thread (ce thread récupère l'adresse IP d'un nom DNS):

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
 
	// ***************************************************************
	// evenements
	private class ActionListener_bouton1 implements ActionListener{
 
		private Thread t;
 
		@Override
		public void actionPerformed(ActionEvent arg0){
 
			t = new Thread(new ThreadConfig());
			t.start();
 
		}
	}
 
 
	// ***************************************************************
	// configuration du module
	class ThreadConfig implements Runnable{
 
		@Override
		public void run() {
			InetAddress addrIP;
			String host = textField1.getText();
 
			textPane1.setText("");
			bouton1.setText("Arrêter");
 
			try {
				addrIP = InetAddress.getByName(host);
				textPane1.setText("1- Connexion : " + host + " => " + addrIP.getHostAddress());
 
			} catch(Exception e){	
				textPane1.setText("1- Connexion : " + host + " => Erreur");
				bouton1.setText("Executer");
				return;
			} 
 
			bouton1.setText("Executer");
 
		}  
 
	}

La methode NetworkInterface.getByInetAddress(addrIP) met longtemps à répondre lorsqu'elle ne trouve pas l'adresse IP. Lorsque je lance le thread, je change le text du bouton par "arreter" et une fois terminé, je remet le text à "Executer".
=> comment faire pour le stopper instantanément et ecrire un message dans mon textPane1 pour indiquer que le process à été arrêté (lorsque je reclic sur mon bouton) ?

[le y@m's]

Gestion des threads
Comment terminer un thread sans la méthode stop() ?

[wax78]

Pq pas utiliser Thread.interrupt ?!

(Je ne vois pas comment tuer un thread qui est bloqué par une méthode "bloquante" sans utiliser interrupt, et je serais ravi de savoir comment faire d'autre si quelqu'un le sait)

[tchize_]

tu peux très bien utiliser interrupt, c'est stop que tu ne peux pas utiliser.

[Emcy]

il me semble que vos methodes (si j'ai bien compris) ne fonctionnent pas => je n'ai qu'une action qui prend du temps (InetAddress.getByName(host)) donc même si je fais un traitement avec Thread.interrupt je ne gagnerai quasiment rien car je suis dans tous les cas obligé d'attendre la fin de l'execution de InetAddress.getByName(host) ... je ne dis pas de betises au moins ?

[wax78]

Sans vouloir, je pense que cela fonctionne avec l'interrupt

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
class ThreadConfig extends Thread{
 
	@Override
	public void run() {
		try
		{
		InetAddress addrIP;
		String host = "www.google.cml";
 
		System.err.println("wait");
			addrIP = InetAddress.getByName(host);
			System.err.println("wait ok");		
		} 
		/*catch(InterruptedException e){	
			return;
		}*/
		catch(Exception e){	
			return;
		}
 
 
 
 
 
 
	}  
 
 
	public static void main(String args[]) throws InterruptedException
	{
		ThreadConfig t = new ThreadConfig();
		t.start();
		t.sleep(100);
		t.interrupt();
		System.err.println("interrompu");
 
	}
}

Tu vas donc gagner du temps à ne pas devoir obligatoiremenet attendre la fin du getByName() dans le meilleur des cas

[Emcy]

Sans vouloir, je pense que cela fonctionne avec l'interrupt

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
class ThreadConfig extends Thread{
 
	@Override
	public void run() {
		try
		{
		InetAddress addrIP;
		String host = "www.google.cml";
 
		System.err.println("wait");
			addrIP = InetAddress.getByName(host);
			System.err.println("wait ok");		
		} 
		/*catch(InterruptedException e){	
			return;
		}*/
		catch(Exception e){	
			return;
		}
 
 
 
 
 
 
	}  
 
 
	public static void main(String args[]) throws InterruptedException
	{
		ThreadConfig t = new ThreadConfig();
		t.start();
		t.sleep(100);
		t.interrupt();
		System.err.println("interrompu");
 
	}
}

Tu vas donc gagner du temps à ne pas devoir obligatoiremenet attendre la fin du getByName() dans le meilleur des cas

je n'ai pas bien compris ton exemple : tout d'abord je n'ai pas le droit de déclarer ta fonction main dans mon exemple et je ne vois pas pourquoi lancer t.interrupt(); (sans rien faire d'autre) stoperai l'execution de InetAddress.getByName(host);

voici mon code complet actuel :

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
 
	// ***************************************************************
	// evenements lorsqu'on clic sur bouton 1
	private class ActionListener_bouton1 implements ActionListener{
 
		private Thread t = new Thread();
 
		@Override
		public void actionPerformed(ActionEvent arg0){
 
 
				if (t.isAlive() == false){
					t = new Thread(new ThreadConfig());
					t.start();
				} else {
					t.interrupt();
				}
 
		}
	}
 
 
	// ***************************************************************
	// configuration du module
	class ThreadConfig implements Runnable{
 
		@Override
		public void run() {
			InetAddress addrIP;
			String host = textField1.getText();
 
			//System.out.println("thread on");
			textPane1.setText("");
			bouton1.setText("Arrêter");
 
			try {
				addrIP = InetAddress.getByName(host);
				//NetworkInterface varNI = NetworkInterface.getByInetAddress(addrIP);
 
 
				//textPane1.setText("1- Connexion : " + host + " => " + addrIP.getHostAddress() + " / " + varNI.getHardwareAddress());
				//textPane1.setText("1- Connexion : " + host + " => " + addrIP.getHostAddress() + " " + toHexaString(varNI.getHardwareAddress()));
 
				if (Thread.currentThread().isInterrupted() == false){
					textPane1.setText("1- Connexion : " + host + " => " + addrIP.getHostAddress());
				} else {
					textPane1.setText("1- Connexion : " + host + " => Thread interrompu");
					bouton1.setText("Executer");
					return;			
				}
			} catch(Exception e){	
				//e.printStackTrace();
 
				if (Thread.currentThread().isInterrupted() == false){
					textPane1.setText("1- Connexion : " + host + " => Erreur");
					bouton1.setText("Executer");
					return;
				} else {
					textPane1.setText("1- Connexion : " + host + " => Thread interrompu");
					bouton1.setText("Executer");
					return;			
				}
			} 
 
			bouton1.setText("Executer");
 
		}

=> mon thread met du temps à s'arreter lorsque InetAddress.getByName(host) met du temps à s'executer et pourtant j'utilise bien t.interrupt();

[JeitEmgie]

=> mon thread met du temps à s'arreter lorsque InetAddress.getByName(host) met du temps à s'executer et pourtant j'utilise bien t.interrupt();

getByName() est une fonction que la JVM délègue à la fonction native de l'OS…
elle bloque donc au niveau I/O bas niveau…

et il n'en existe pas de version asynchrone qui accepterait un paramètre timeout…

à faire en C + JNI si vous en avez absolument besoin…

[tchize_]

pas pourquoi lancer t.interrupt(); (ça rien faire d'autre) stoperai l'execution de InetAddress.getByName(host);

parce que, pour la plupart des appels bloquant liés aux io ou au réseau, les méthodes sont interrrompues en lancant un interruptedException si le flag interrupt est passé à true. Maintenant, pour celle là, si ça ne merche pas, tu n'a pas d'autre possibilité que laisser le thread dans son coin jusqu'à la fin de la méthode.

[wax78]

Quand je teste ici au taf, cela fonctionne en mettant n'importe quelle addresse qui existe pas et qui mets plusieurs seconde à etre "non resolue". L'interrupt fonctionne et arrete l'execution de mon thread. Mon exemple est un peu scabreux mais il fonctionne. Il suffit de le lancer avec et sans les lignes

Code :

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

1
2
3
4
 
t.sleep(100);
t.interrupt();
System.err.println("interrompu");

et regarder la console pour constater qu'on voit ou pas le wait ok. (montrant que getByName() s'est terminé sans emcombre ou pas).

[Emcy]

Ok, merci pour les infos (donc si je ne veux pas trop me prendre la tête, je n'ai pas trop le choix => ce n'est pas trop génant).
=> cette limitation est du au langage java en particulier ou à tous les langages orientés objet en générale (est-ce qu'en C++ j'aurais eu le même problème) ?
Pour le moment, je n'ai pas encore figé le choix du langage à utiliser (vu que je commence) : le langage java m'avait l'air pas mal mais je n'ai pas assez de connaissances sur tous les langages pour faire un choix en fonction des réelles capacités de chaque langages.
=> j'ai besoin de faire des appli qui sont orientés essentiellement réseau (envoi de formulaire, lecture/analyse de page web, détection d'appareils sur le réseau, utilisation bas niveau de protocole réseau udp/tcp/icmp/...)
Quels sont les avantages du langage java par rapport aux autres langages orientés objet ?
Remarque : je maitrise assez bien le langage C

L'interrupt fonctionne et arrete l'execution de mon thread.

=> l'exécution s'arrête instantanément ?

[tchize_]

quel que soit le language utilisé, à un moment ou un autre, c'est au thread de décider d'arreter son travail. Au niveau de l'OS, a part tuer le processus propriétaire, il n'existe pas de moyen de tuer un thread proprement (et pour cause, tu sais pas dans quel état sera la mémoire de ton processus une fois un thread arreté sauvagement. Qu'en est-il de ses locks, de ses données à moitié écrite, des ses connections réseau, ....)

[Uther]

=> l'exécution s'arrête instantanément ?

En fait le principe de l'interrupt() est qu'il positionne le Thread dans l'état "interrupted". Cela n'a pas pour effet de forcer l'interrution immédiate du Thread. Cependant les fonctions potentiellement bloquantes se doivent de surveiller l'état du thread. S'il est a l'état interrompu, elle devraient se débloquer ou lever une exception (et donc indirectement se débloquer).

Malheureusement certaines fonctions longues font cette vérification, d'autres non.
Thread.sleep() gère en effet le interrupt(), cependant je ne sais pas si c'est le cas de getByInetAddress(). Il te faudrait vérifier cela.

[wax78]

=> l'exécution s'arrête instantanément ?

Ecoute, dans mon exemple (retravaillé) je constate qu'il faut 0 secondes pour interrompre le thread... Alors soit nous ne nous comprennons pas, soit je ne sais pas ^^ je dois avoir un truc magique sur l'ordinateur. (Probablement ce que Uther explique).

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
 
class ThreadConfig extends Thread{
 
	@Override
	public void run() {
		try
		{
			InetAddress addrIP;
			String host = "www.google.ERR";
			System.err.println("WAIT GETBYNAME() - Je reste bloqué quelques secondes car www.google.ERR n'existe pas");
			addrIP = InetAddress.getByName(host);
			System.err.println("GETBYNAME() FINI - J'ai trouvé (ou pas ...)");		
		} 
		catch(Exception e){	
			return;
		}
	}  
 
 
	public static void main(String args[]) throws InterruptedException
	{
		ThreadConfig t = new ThreadConfig();
		t.start();
		t.sleep(100); // porcherie pour etre sure qu'il est bien arrivé au moment du getByName dans le thread.
		long start = System.currentTimeMillis();
		t.interrupt();
		long stop = System.currentTimeMillis();
		long elapsed = stop-start;
		System.err.println("Interrompu en "+elapsed);
 
	}
}

Si tu decommentes :

Code :

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

1
2
 
t.interrupt();

Et tu vas voir que le truc reste bien bloqué pdt plusieur seconde a essayer de resoudre le nom google.ERR qui evidement n'existe pas.

[wax78]

Dans le cas du sleep() en effet, mais je ne sais pas si c'est le cas de getByInetAddress(). Il te faudrait vérifier cela.

Le sleep t'oblige a mettre un InerruptedException mais pas getByInetAddress.

[Uther]

Donc il est probable que ça ne marche pas pour le getByInetAddress.

[tchize_]

Ecoute, dans mon exemple (retravaillé) je constate qu'il faut 0 secondes pour interrompre le thread... Alors soit nous ne nous comprennons pas, soit je ne sais pas ^^ je dois avoir un truc magique sur l'ordinateur. (Probablement ce que Uther explique).

ce qui se passe, c'est simplement que la méthode blocante que tu appelle est propre et vérifier l'état de l'interrupt. Note que si cette méthode se base sur des socket, les socket, elles, gèrent le interrupted, ce qui aurait pour conséquence indirecte que la résolution retourne un hote inconnu et le code de ton thread repend la main (et peux alors décider de quitter sur base du flag interrupted)

[wax78]

ce qui se passe, c'est simplement que la méthode blocante que tu appelle est propre et vérifier l'état de l'interrupt. Note que si cette méthode se base sur des socket, les socket, elles, gèrent le interrupted, ce qui aurait pour conséquence indirecte que la résolution retourne un hote inconnu et le code de ton thread repend la main (et peux alors décider de quitter sur base du flag interrupted)

Merci pour ces precisions, ca me parait logique expliqué comme cela.

[Emcy]

Ecoute, dans mon exemple (retravaillé) je constate qu'il faut 0 secondes pour interrompre le thread... Alors soit nous ne nous comprennons pas, soit je ne sais pas ^^ je dois avoir un truc magique sur l'ordinateur. (Probablement ce que Uther explique).

ben j'ai bien testé ton exemple et je confirme que le thread ne met pas 0 secondes à s'arreter => il continu bien de tourner même si tu fais un t.interrupt();

Le temps que tu mesures n'est pas le temps d'exécution du thread mais le temps d'exécution de la fonction main
Dans ton exemple que je mette t.interrupt(); ou pas, ça ne change pas grand chose au fonctionnement...


j'ai modifier ton exemple pour mettre en évidence le problème :

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
 
	import java.net.InetAddress;
 
	class testThread extends Thread{
 
		@Override
		public void run() {
			long start = System.currentTimeMillis();
			System.err.println("Lancement du thread");
 
			try
			{
				InetAddress addrIP;
				String host = "www.google.err";
				System.err.println("WAIT GETBYNAME() - Je reste bloqué quelques secondes car www.google.ERR n'existe pas");
				addrIP = InetAddress.getByName(host);
				System.err.println("GETBYNAME() FINI - J'ai trouvé");		
			} 
			catch(Exception e){	
				System.err.println("GETBYNAME() FINI - Je n'ai pas trouvé");	
				//return;
			}
 
			if (Thread.currentThread().isInterrupted() == true){
				System.err.println("Le Thread a été interropu");
			}
 
			System.err.println("Temps d'execution du thread : " + (System.currentTimeMillis()-start));
		}  
 
		public static void main(String args[]) throws InterruptedException
		{
 
 
			testThread t = new testThread();
			t.start();
			t.sleep(100); // porcherie pour etre sure qu'il est bien arrivé au moment du getByName dans le thread.
			t.interrupt();
 
		}
 
	}

je ne dis pas de betises ?

[tchize_]

no, tu dis pas de bétise, tu fait bien de le faire remarqué. Si la résolution de nom ne répond pas aux interrupt, t'as plus d'autre choix que d'attendre.