Discussion :

[®om]

Salut,

Je souhaiterais reproduire le mécanisme de SwingUtilities.invokeLater(), c'est-à-dire avoir une file (FIFO) de Runnable qui s'exécutent les uns à la suite des autres dans un Thread séparé (mais bien sûr différent de l'EDT, contrairement à SwingUtilities.invokeLater()).
Et de préférence, quelque chose déjà présent dans l'API ^^ :-)

Vers quel classe dois-je m'orienter?

Merci d'avance :-)

[afrikha]

Tu peux utiliser la nouvelle api intégré à java 5, à savoir java.util.concurrent
Elle te permettra de créer un pool de thread (ou même un seul thread ) le plus facilement du monde.
Je pourrais t'aider d'avantage si tu détailles un peu plus ce que tu souhaite faire.

[®om]

Merci de ta réponse, je vais regarder de ce côté là...

Ce que je souhaite faire:
J'ai une liste (de 113 éléments actuellement), et un composant de recherche en dessous, qui fait office de filtre de la liste...
Dès qu'on modifie le texte du composant de recherche, la liste est filtrée (c'est une liste de chaîne, si dans la recherche il y a un numéro ou un bout de nom de chaîne, par exemple "France", alors les chaînes "France 2", "France 3", "France ô"... s'afficheront dans la liste).
Bon, en fait là ça marche bien, mais le problème c'est que l'algorithme de filtrage est effectué dans l'EDT, et si je souhaite le complexifier un peu, ça risque de freezer quelques millisecondes
Donc je pourrais lancer un Thread et mettre à jour la liste dans ce Thread par SwingUtilities.invokeLater(), mais si on écrit très vite dans le composant de recherche, ça lance plusieurs Threads en simultané et on ne sait pas dans quel ordre ils vont se terminer (ça sera peut-être la première requête exécutée en dernier).
C'est pour ça que je voudrais lancer ces Threads les uns après les autres (ou un seul Thread qui exécute les actions les unes après les autres).

Là c'est pour mon exemple actuel, mais j'aurai besoin exactement de la même chose pour une récupération de données dans une db par la suite (pour exécuter les requêtes les unes après les autres si plusieurs sont demandées en mm tps)...

[®om]

D'après le package que tu m'as indiqué, je pense qu'il faut utiliser:

Code :

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

Executors.newSingleThreadExecutor()

pour récupérer un ExecutorService...

Mais ensuite ?

Et quelle est la différence entre Callable et Runnable ?

EDIT:
Ah peut-être:

Code :

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

1
2
ExecutorService pool = Executors.newSingleThreadExecutor();
pool.execute(myRunnable);

?

[afrikha]

Ok, j'ai bien compris maintenant. En fait ce que tu cherches à faire c'est une file avec un unique thread qui exécuterait les tâches dans la file les une après les autres (corrige moi si je me trompe ).
Dans ce cas, il suffit de faire :

Code :

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

1
2
3
4
5
6
 
ExecutorService executeurDeTache=Executors.newSingleThreadExecutor();
//lancement des taches
executeur.execute(monRunnable1);
executeur.execute(monRunnable2);
...

Si tu as besoin de plus de threads,regarde du coté de Executor qui fournit plein de méthodes statiques.

[Baptiste Wicht]

Je sais pas ce que vaut mon idée, mais tu peut aussi faire tout simplement un thread qui a comme attiribut une arrayList de Thread ou de Runnable et qui les éxécute les uns après les autres en attendant chaque fois la fin du précédent. Dès qu'il en a plus, il attend (listener ?) qu'un autre thread soit ajouté et l'éxécute.

[®om]

Ok, j'ai bien compris maintenant. En fait ce que tu cherches à faire c'est une file avec un unique thread qui exécuterait les tâches dans la file les une après les autres (corrige moi si je me trompe ).
Dans ce cas, il suffit de faire :

Code :

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

1
2
3
4
5
6
 
ExecutorService executeurDeTache=Executors.newSingleThreadExecutor();
//lancement des taches
executeur.execute(monRunnable1);
executeur.execute(monRunnable2);
...

Si tu as besoin de plus de threads,regarde du coté de Executor qui fournit plein de méthodes statiques.

OK merci, c'est nickel :-)

Bien pratique :-)

On se demande comment certains peuvent se passer de java 1.5 :-)

[®om]

Et encore une petite question...

Pour la liste des chaînes, j'ai essayé ça c'est nickel...

Maintenant, pour l'accès à la base de données, je voudrais faire quasiment pareil, sauf que je voudrais que seule la dernière demande de requête soit exécutée...
Par exemple:

Code :

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

1
2
|  A  |  B  |     C     | D |   E   |
-------->

A B C D E sont 5 requêtes, la flèche indique où en est le Thread (au milieu du B).
Donc là par exemple, il a exécuté A, il est en train d'exécuter B, et je veux que le prochain soit E (qu'il mette à la poubelle C et D), car par exemple si je demande de chercher qqch, puis encore autre chose, je peux abandonner l'ancienne recherche...

Je pense qu'il y a une solution simple dans l'API, mais je ne sais pas où :-)

Merci d'avance

[adiGuba]

Salut,


Dans le package concurrent tu as les BlockingQueue qui permettent de faire cela.
Les BlockingQueue sont des Queue synchronizés destiné à être utilisé pour passer des données entre deux Threads.

Dans ton cas cela pourrait donner :

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
public class Traitement implements Runnable {
 
    private final BlockingQueue<String> queue = new LinkedBlockingQueue<String>();
    private final Thread thread;
 
    public Traitement() {
        this.thread = new Thread(this, "Traitement");
        this.thread.start();
    }
 
    public void invokeLater(String s) {
        this.queue.offer(s);
    }
 
    public void stop() {
        this.thread.interrupt();
    }
 
    public void run() {
        try {
            while (!this.thread.isInterrupted()) {
 
                // On attend de récupérer les données :
                // take() est bloquant si la queue est vide
                String data = this.queue.take(); 
 
                // On vide la queue :
                String tmp;
                // poll() n'est pas bloquant et renvoit null si la queue est vide
                while ( (tmp=this.queue.poll()) != null ) { 
                    data = tmp;
                }
 
                // On traite les données :
                System.out.println("Received : " + data);
            }
        } catch (InterruptedException e) {
            // Interruption du tread : fin du thread
        }
    }
 
    public static void main(String[] args) throws Exception {
 
        Traitement t = new Traitement();
 
        t.invokeLater("data 1");
        t.invokeLater("data 2");
        t.invokeLater("data 3");
        t.invokeLater("data 4");
        t.invokeLater("data 5");
 
        Thread.sleep(1000);
 
        t.invokeLater("data 6");
        t.invokeLater("data 7");
        t.invokeLater("data 8");
        t.invokeLater("data 9");
        t.invokeLater("data 10");
 
 
        Thread.sleep(1000);
 
        t.stop();
    }
}

a++

[®om]

Merci beaucoup adiGuba.

J'ai adapté un peu ton code, ce qui donne : (voir fin de post).

Par contre, au niveau des Threads, je me pose une question...
Comment isInterrupted() peut retouner vrai, car si le Thread est interrompu, il ne s'exécute plus, si?

PS: Si tu as des remarques sur le code, n'hésite pas ;-)

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
package org.myfreetv.core.executor;
 
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
 
/**
 * Exécuteur de tâches. Si plusieurs tâches sont en attente, seule la dernière est traitée, les autres sont ignorées.
 * 
 * @author rom1v
 */
public class TaskExecutor implements Executor {
 
    /** Liste bloquante des tâches. */
    private final BlockingQueue<Runnable> tasks = new LinkedBlockingQueue<Runnable>();
 
    /** Thread dans lequel sont exécutées les tâches. */
    private Thread thread;
 
    /**
     * Crée un exécuteur de tâches.
     */
    public TaskExecutor() {
        thread = new Thread() {
 
            @Override public void run() {
                while(!isInterrupted()) {
                    Runnable current = null;
                    try {
                        /* On attend que la liste ne soit pas vide (attente bloquante). */
                        current = tasks.take();
                    } catch(InterruptedException e) {}
 
                    /* S'il n'y a pas eu d'interruption. */
                    if(current != null) {
                        /* On ne garde que la dernière tâche demandée. */
                        Runnable tmp = tasks.poll();
                        while(tmp != null) {
                            current = tmp;
                            tmp = tasks.poll();
                        }
 
                        /* On exécute la tâche, s'il y a un problème, on passe à la tâche suivante. */
                        try {
                            current.run();
                        } catch(Exception exc) {
                            exc.printStackTrace();
                        }
                    }
                }
            }
        };
        thread.start();
    }
 
    /**
     * Met en file une nouvelle tâche.
     * 
     * @param task
     *            Tâche à mettre en file.
     */
    public void execute(Runnable task) {
        tasks.offer(task);
    }
 
    /**
     * Stoppe l'exécuteur de tâche après la tâche courante.
     */
    public void shutdown() {
        thread.interrupted();
    }
 
    /**
     * Indique si l'exécuteur de tâches est arrêté.
     * 
     * @return <code>true</code> si l'exécuteur de tâches est arrêté.
     */
    public boolean isShutdown() {
        return !thread.isAlive();
    }
 
}

[marchand_de_sable]

Comment isInterrupted() peut retouner vrai, car si le Thread est interrompu, il ne s'exécute plus, si?

Si j'ai bien compris les bases des threads, le fait d'être "interrompu" correspond à un état du thread, tout comme "prêt", "en attente" ou "en cours d'exécution".

En d'autre termes, le thread, même interrompu, existe toujours, à moins qu'on le "tue" explicitement après exécution ou interruption.

(désolé, il doit exister un vocabulaire spécifique pour ce que je viens de dire, mais je ne le maîtrise pas )

[®om]

Si j'ai bien compris les bases des threads, le fait d'être "interrompu" correspond à un état du thread, tout comme "prêt", "en attente" ou "en cours d'exécution".

En d'autre termes, le thread, même interrompu, existe toujours, à moins qu'on le "tue" explicitement après exécution ou interruption.

(désolé, il doit exister un vocabulaire spécifique pour ce que je viens de dire, mais je ne le maîtrise pas )

Donc par exemple, pour mon test:

Code :

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

if(current != null)

c'est équivalent à:

Code :

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

if(!isInterrupted())

dans le cas de ma classe?

[®om]

Et sinon, la classe ThreadPoolExecutor ne permettrait pas de faire qqch comme ça? (je suis en train de regarder, mais y'a beaucoup de méthodes et de paramètres au constructeur)...

EDIT:
Que pensez-vous de cela?!

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 org.myfreetv.core.executor;
 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
/**
 * Exécuteur de dernière tâche demandée. Si plusieurs tâches sont en attente, seule la dernière est traitée, les autres
 * sont ignorées.
 * 
 * @author rom1v
 */
public class LastTaskExecutor extends ThreadPoolExecutor {
 
    /**
     * Crée un exécuteur de dernière tâche demandée.
     */
    public LastTaskExecutor() {
        super(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
    }
 
    /**
     * Met en file d'attente une tâche à exécuter.
     */
    @Override public void execute(Runnable runnable) {
        /* On vide la liste des tâches. */
        getQueue().clear();
 
        super.execute(runnable);
    }
 
}

Je me demande si vider le premier élément de la liste des tâches peut provoquer un problème lorsque le runnable est en cours d'exécution... Je vais tester

EDIT2: Cela a l'air de marcher... Enfin je ne peux pas trop tester si ça supprime bien ce qu'il faut dans mon appli, c'est trop rapide... Faudrait faire des tests avec des Thread.sleep()

[adiGuba]

Si j'ai bien compris les bases des threads, le fait d'être "interrompu" correspond à un état du thread, tout comme "prêt", "en attente" ou "en cours d'exécution".

En d'autre termes, le thread, même interrompu, existe toujours, à moins qu'on le "tue" explicitement après exécution ou interruption.

C'est tout à fait ca !

Lorsque tu appelles la méthode interrupt() sur un Thread, tu modifies seulement son état à INTERRUPTED, et si tu es dans une méthode bloquante, celle-ci peut renvoyer une InterruptedException (cela dépend des méthodes, voir la doc).

Ainsi cela permet de finir proprement ton thread. Si stop() a été déprécié c'est parce qu'il arrêtait le thread brusquement, et que tu pouvais te retrouver avec des données dans un état incohérent...


Sinon, ThreadPoolExecutor doit fait l'affaire également.


a++

[afrikha]

Salut adiGuba,

Ainsi cela permet de finir proprement ton thread

Pourrais-tu détailler un peu plus s'il te plait ?

Merci

[divxdede]

Et sinon, la classe ThreadPoolExecutor ne permettrait pas de faire qqch comme ça? (je suis en train de regarder, mais y'a beaucoup de méthodes et de paramètres au constructeur)...

EDIT:
Que pensez-vous de cela?!

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 org.myfreetv.core.executor;
 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
/**
 * Exécuteur de dernière tâche demandée. Si plusieurs tâches sont en attente, seule la dernière est traitée, les autres
 * sont ignorées.
 * 
 * @author rom1v
 */
public class LastTaskExecutor extends ThreadPoolExecutor {
 
    /**
     * Crée un exécuteur de dernière tâche demandée.
     */
    public LastTaskExecutor() {
        super(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
    }
 
    /**
     * Met en file d'attente une tâche à exécuter.
     */
    @Override public void execute(Runnable runnable) {
        /* On vide la liste des tâches. */
        getQueue().clear();
 
        super.execute(runnable);
    }
 
}

Je me demande si vider le premier élément de la liste des tâches peut provoquer un problème lorsque le runnable est en cours d'exécution... Je vais tester

EDIT2: Cela a l'air de marcher... Enfin je ne peux pas trop tester si ça supprime bien ce qu'il faut dans mon appli, c'est trop rapide... Faudrait faire des tests avec des Thread.sleep()

L'idée est bonne, mais tu aurais plus simplement a annulé les taches precedentes grace à la méthode cancel() des "Future" retourné par l'ExecutorService

[®om]

L'idée est bonne, mais tu aurais plus simplement a annulé les taches precedentes grace à la méthode cancel() des "Future" retourné par l'ExecutorService

Quel méthode te retourne la liste des Future?
Car à part les submit() et invokeAll(), je vois pas ;-)

[divxdede]

Quel méthode te retourne la liste des Future?
Car à part les submit() et invokeAll(), je vois pas ;-)

Au lieu de faire des execute() tu fais des submit()

Tu gardes toujours la reference du dernier "Future" que tu as soumis a l'executeur.
Et avant de faire un nouveau "submit" tu cancel l'ancien en faisant Future.cancel(..)

J'utilise cette technique pour désyncrhoniser le chargement d"une preview dans un wizard