Discussion :

[elmaestro]

Bonjour,

Malgré les innombrables tutoriels (dont cet excellent ici) lus sur le sujet épineux du cycle de vie des Thread, je n'arrive toujours pas à tuer le mien.

D'une autre classe, j'invoque sa méthode doStop() et je teste l'état du Thread avec isThreadAlive() qui me retourne toujours RUNNABLE au lieu de TERMINATED :

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
public class ControlReader implements Runnable{
 
    ObjectInputStream inputStream;
    private String readerMessage;
    private volatile Thread currentThread = null;
 
    public ControlReader(ObjectInputStream in){
        this.inputStream = in;
    }
 
    public String getMessage(){
        return readerMessage;
    }
 
    public String isThreadAlive(){
        return currentThread.getState().toString();
    }
 
    public void doStop(){
        currentThread.interrupt();
    }
 
    public void run() {
        currentThread = Thread.currentThread();
        while(!currentThread.isInterrupted()){
            try {
                readerMessage = (String)inputStream.readObject();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    
}

Nota : Je précise que lorsque tout ceci tourne, le processus est bloqué sur le code en ligne 27 readerMessage = (String) inputStream.readObject();
Normal, car ma classe Runnable attend un message du l'application Client.

Quelqu'un saurait-il m'expliquer ce qui ne va pas ?

Merci d'avance pour votre aide.

[Mathieu.J]

Il ne semble pas y avoir d'état particulier pour un thread bloqué par ton read() même si il est marqué comme interrupted il est toujours en train de s'exécuter. C'est sûrement pour cela que tu obtient toujours RUNNABLE.

NEW
A thread that has not yet started is in this state.
RUNNABLE
A thread executing in the Java virtual machine is in this state.
BLOCKED
A thread that is blocked waiting for a monitor lock is in this state.
WAITING
A thread that is waiting indefinitely for another thread to perform a particular action is in this state.
TIMED_WAITING
A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
TERMINATED
A thread that has exited is in this state.

J'ai également trouvé ça :

Once a thread calls read() it will not respond to interrupt() (or much else) until the read is completed.

Source

[elmaestro]

J'apporte une précision de taille :

Mon Thread reste pour la plupart du temps bloqué (en attente de l'arrivée d'une donnée sur l'inputstream)...normal !

Ce que je souhaite, c'est intercepter le moment où le Client (celui qui envoi les message) est déconnecté.

Il se trouve qu'à la déconnexion du Client, le try/catch qui contrôle le code InputStream.ReadObject() lève une exception...super !

L'idée est donc de saisir cette occasion pour indiquer à la classe parente qu'il faut quelle "tue" proprement le Thread pour le recréer.

Je crois avoir constaté (en mode debug) que l'exception (IOException) met fin à la boucle While, mais je n'ai pas l'impression que le Thread est killed.

Une petite idée pour me sortir de cet eccueil ?

Ci-après le code en question :

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
public class ControlReader implements Runnable{
 
	ObjectInputStream inputStream;
	private String readerMessage;
	private volatile Thread currentThread = null;
 
	public ControlReader(ObjectInputStream in){
		this.inputStream = in;
	}
 
	public String getMessage(){
		return readerMessage;
	}
 
	public String isThreadAlive(){
		return currentThread.getState().toString();
	}
 
	public void doStop(){
		currentThread.interrupt();
	}
 
	public void run() {
		currentThread = Thread.currentThread();
		while(!currentThread.isInterrupted()){
			try {
				readerMessage = (String)inputStream.readObject();
			} catch (IOException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		try {
			inputStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}	
 
}

[elmaestro]

J'y suis arrivé, tout fonctionne.

Lorsque l'application Client est déconnectée, cela génère côté Serveur une IOException (ligne 28) au niveau de la méthode .readObject() qui n'a plus rien à écouter.

Je saisi cette occasion pour lever un événement qui au final à pour conséquence un appel à la méthode .doStop() ; celle-ci qui invoque un .interrupt() sur le fameux Thread.

Voici le code :

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 RemoteControlReader implements Runnable{
 
    ObjectInputStream inputStream;
    private String readerMessage;
    private volatile Thread currentThread = null;
 
    public RemoteControlReader(ObjectInputStream in){
        this.inputStream = in;
    }
 
    public void doStop(){
        currentThread.interrupt();
    }
 
    @Override
    public void run() {
 
        currentThread = Thread.currentThread();
 
        try{
 
            while(!currentThread.isInterrupted()){
 
                try {
 
                    readerMessage = (String)inputStream.readObject();
 
                } catch (IOException e) {
 
                    e.printStackTrace();
 
                    raiseMyEnent("Le client est déconnecté");
 
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
 
                Thread.sleep(1000);
            }
 
        } catch (InterruptedException e){
            e.printStackTrace();
        }
 
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    
}

Merci à tous pour vos lumières.

[Robin56]

Bonjour et merci pour ton retour. Si ton problème est solutionné, n'oublie pas de le passer à l'état résolu (bouton ).

[thelvin]

Au passage, je n'ai pas compris pourquoi il fallait absolument appeler interrupt() sur ce thread qui s'arrête tout seul comme un grand.