Discussion :

[fmilin]

Bonjour :

Je ne comprends pas très bien la façon dont fonctionne l'API thread sous java.

On dit qu'il y a deux façon d'implémenter un thread en java.

Prenons l'exemple de l'implementation de l'interface runnable :

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
class RunnableThread implements Runnable {
 
	Thread runner;
	public RunnableThread() {
	}
	public RunnableThread(String threadName) {
		runner = new Thread(this, threadName); // (1) Create a new thread.
		System.out.println(runner.getName());
		runner.start(); // (2) Start the thread.
	}
	public void run() {
		//Display info about this particular thread
		System.out.println(Thread.currentThread());
	}
}

1. La classe implemente l'interface runnable, et fournie donc la méthode RUN qui doit être exécutée par le thread.

2. Un thread est créé en passant la référence de la classe RunnableThread au constructeur de l'objet thread.

Les constructeurs de thread n'accepte que des objets de type Runnable.
Doit t'on considérer l'objet RunnableThread comme un objet de type Runnable à partir du moment ou il implemente l'interface Runnable.
Si ce n'est pas le cas je ne comprends l'adequation entre le type RunnableThread et celle du constructeur de thread.

Merci de vos réponses.

[Fmunch]

Bonjour,

Souvent les exemples sont écrit de cette façon, mais tu pourrais très bien crée une autre classe implémentant Runnable et qui fait la même chose. L'avantage de déclaré la classe ainsi ou d'utiliser une classe interne est d'avoir facilement accès aux éléments de ta classe. Tu pourrais par exemple étendre une JPanel, et dessiner dessus : la méthode run aura accès a toutes les fonctionnalités du JPanel.

[deglingo592003]

Je me suis mis au thread il y a peu, je vais essayé de t'éclairer même si au final je ne suis pas encore au point, j'espère que cela t'aidera quand même

donc attend confirmation de mon poste par quelqu'un de plus expérimenté :p

Si je ne dit pas de bêtise tu a plusieurs solutions

soit tu peut déclarer a l'intérieur de ta classe, de ce fait tu a accès plus facilement au variable de ta classe

soit tu défini un fichier à part et tu défini les variable dont tu a besoin en variable globale pour les utiliser un peu partout où tu en a besoin

pour ce qui est de la création du thread en lui même tu as encore deux solution

soit tu as class MonThread extends Thread

ou seconde solution class MonThread implement Runnable

qui au final fonctionne de la même manière avec l'appelle a la fonction public void run()

donc

1) oui au final au lieu d'exécuter un main() tu exécute un run()

2)pour le constructeur, tu peut le définir comme tu le veux, à partir du moment où tu implement la méthode run (quand tu instancie ton thread, il passe par le constructeur puis immédiatement après il passe sur la méthode run() si je ne dit pas de bêtise ( ce qui est souvent le cas ^^))

un implement te permet d'utiliser les méthode d'une interface en redéfinissant ses méthode en fonction de tes besoins, donc au final tu crée ton runnable oui mais au final ton constructeur tu le défini comme tu veux

[bigbear19]

Bonjour,

Utiliser l'interface Runnable permet de proposer une alternative à l'héritage de la classe Thread qu'on ne peut pas utiliser dans tous les cas (l'héritage multiple n'étant pas autorisé en Java).

Donc soit tu crées une classe MonThread extends Thread, que tu lances de cette manière:
new MonThread().run();

soit tu crées une classe MonRunnable implements Runnable que tu lances de cette manière:
new Thread(new MonRunnable()).run();

[Antoine_935]

new MonThread().run();

Surtout pas malheureux
C'est la méthode start() qu'il faut appeler. C'est cette méthode qui démarre tout le côté asynchrone de la thread.


ll y a plusieurs manières de démarrer une thread. Si tu as juste besoin d'appeler une méthode en asynchrone, le plus simple est ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
// du code...
 
new Thread() {
    @Override
    public void run() {
        laMethode();
    }
}.start();
 
// suite du code...

Tu peux aussi, bien sur, créer une classe qui hérite de thread.
On se sert moins souvent de Runnable, c'est plutôt quand tu dois passer un argument à une méthode qui lancera plus tard ce Runnable.
De plus, rien ne spécifie que ce Runnable sera lancé dans une thread. Il se peut tout à fait qu'il soit lancé en synchrone.

N'hésite pas à regarder du côté de synchronized et des locks, une fois que tu es à l'aise avec les threads

[bigbear19]

C'est la méthode start() qu'il faut appeler.

Au temps pour moi

[titourock]

Bonjour,

Il y a deux façons de créer des threads soit en dérivant de la classe Thread soit en implémentant la classe Runnable.

La première façon de faire est limitée car, en java, il est impossible d'hériter de plus d'une classe. Ainsi, si l'on désire hériter des propriétés d'une classe A déjà définie, il est alors impossible d'hériter de Thread...

La deuxième façon permet de contourner ce problème et ce n'est pas spécifique aux Threads en utilisant les interfaces pour palier le problème du multihéritage...d'où l'interface Runnable.
Enfin, de manière générale, un objet implémentant une interface I est un objet de type I, ce qui permet d'utiliser des objets n'ayant "aucun rapport" (au sens pas de lien de parenté entre eux) de manière générique en ne les considérant que comme des objets de type I...