IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Concurrence et multi-thread Java Discussion :

Bien implémeter les threads


Sujet :

Concurrence et multi-thread Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé Avatar de kerinel
    Profil pro
    Inscrit en
    Février 2007
    Messages
    103
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 103
    Par défaut Bien implémeter les threads
    Bonjour,
    je me lance dans les threads et j'ai donc bouquiné un peu et j'ai lu 2 trucs completement opposés.

    - Un cours sur Internet disait que la plus simple manière de créer un Thread est de dériver la classe Thread pour faire une classe fille de Thread et y mettre tout ce que doit faire le thread.

    - dans un bouquin, je lis que c'est souvent la plus mauvaise méthode et qu'il convient plutot de faire gérer les Threads par la classe en ayant besoin...

    du coup je ne sais pas trop a quel saint me vouer ... Personnellement je pencherai plus pour la premiere solution, qui me semble plus orientée objet. Mais je peut me tromper.

    Bon la question peut paraitre plus philosophique aue pratique, mais tant quìa faire autant apprendre a faire les trucs proprement

    merci pour vos réponses

    kerinel

  2. #2
    Rédacteur
    Avatar de benwit
    Profil pro
    dev
    Inscrit en
    Septembre 2004
    Messages
    1 676
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : dev

    Informations forums :
    Inscription : Septembre 2004
    Messages : 1 676
    Par défaut
    Bonjour, je vais te donner mon avis sur la question et cela n'engage que moi.

    Il est vrai que dériver de la classe Thread est une façon simple de faire un Thread (quand à savoir si c'est la plus simple, c'est assez philosophique : dériver, implémenter, agréger, qu'est ce qui est le plus simple ???)
    Je pense que cela peut se justifier au niveau conception objet si la classe dérivée est un objet technique qui représente bien une sorte de processus légér. Tu pourrais par exemple trouver pratique d'avoir une implémentation enrichie d'un Thread.

    Ceci étant dit, je pense que dans le cas d'une application "métier", les objets créés sont plus en rapport avec le domaine métier. Dès lors, je ne pense pas que dériver de Thread soit bon conceptuellement. Mieux vaut au sein de la classe qui veut executer des traitements non bloquant, créer à ce moment là un Thread (classe anonyme généralement) qui executera le code.
    Si tu as des objets métiers qui représentent des traitements, tu peux aussi faire en sorte qu'ils implémentent l'interface Runnable. Cela peut alors te permettre de généraliser comme te l'aurai permis une dérivation de Thread.

    Pour conclure, je dirai que l'héritage est quelque chose de formidable. Il est probablement le paradigme de la POO qui est le plus vite compris. A tel point que le gros défaut des débutants est alors de vouloir l'utiliser pour tout et n'importe quoi. Je pense qu'il faut l'utiliser lorsque qu'on souhaite à la fois une relation "est un" et une factorisation de code. Dans les autres relations "est un", les interfaces sont plus appropriées.

  3. #3
    Membre éprouvé Avatar de nicgando
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    128
    Détails du profil
    Informations personnelles :
    Âge : 44
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Mars 2006
    Messages : 128
    Par défaut
    Je suis du même avis que Benwit.
    Car implémenter Runnable rend la classe plus flexible:
    - elle peut toujours hériter d'une autre classe
    - elle peut lancer elle même son code dans un thread séparé: new Thread(this).start();
    - on peut déléguer le choix de l'exécution du code Runnable à une autre classe qui pourra faire laClasse.run() pour être synchrone ou bien new Thread(laClasse).start(); pour être asynchrone

  4. #4
    Membre confirmé Avatar de kerinel
    Profil pro
    Inscrit en
    Février 2007
    Messages
    103
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 103
    Par défaut
    Donc faire un "clignoteur" juste pour faire clignoter mes Digits, c'est pas une bonne idée. Il faut plutot que je fasse une methode clignoter, que j'implemente Runnable avec
    public void run() [ clignoter();]
    (desole je trouve pas les accolades sur ce clavier )
    et que quand j'ai besoin de faire clignoter je fasse
    new Thread(this).start();

    Mais si du coup je veux pouvoir faire un second Thread dessus qui lui me permet de faire defiler du texte.
    si je n'ai pas la fonction clignoter, je peux faire pareil avec une methode defiler et
    public void run()[defiler();]

    Masi comment faire pour faire cohabiter les deux, schant que je peux vouloir faire clignoter sans faire defiler, faire defiler sans faire clignoter, ou faire les deux ensemble...

    Du coup je suis bien obligé de définir un objet supplémentaire ? Ou alors je dois utiliser une classe anonyme ? Mais du coup quel est l'avantage par rapport a le derivation d'objet ? Car mon objet est plus facilement controlable que la classe anonyme non ?

    merci
    kerinel

  5. #5
    Membre éprouvé Avatar de nicgando
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    128
    Détails du profil
    Informations personnelles :
    Âge : 44
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Mars 2006
    Messages : 128
    Par défaut
    Tu fais une classe qui sait faire Clignoter
    Tu fais une classe qui sait faire Défiler
    Tu fais une classe TextAnimator qui contient l'un ou l'autre ou les deux pour animer ton texte.
    Cette classe pourra démarrer et arrêter chacunes de ces classes (qui pourraient dérivées d'une même interface TextAnimation qui a startAnimation() et stopAnimation() par exemple
    Comme ça tu peux prévoir d'autres effets comme un changement de couleur ou de police par exemple

    Ps: si tu fais du Swing pense à bien synchroniser tes updates de texte via SwingUtilities

  6. #6
    Membre confirmé Avatar de kerinel
    Profil pro
    Inscrit en
    Février 2007
    Messages
    103
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2007
    Messages : 103
    Par défaut
    Donc pour l'instant mon code ressemble à ça :
    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
     
     
    public class DigitBox{
     
         private Clignoteur cligne;
         private boolean çaNeClignotePas;
     
     
         public DigitBox()  {
     
             je fais la Digit Box qui regroupe les Digits etc...
     
             çaNeClignotePas=true;
     
         }//fin DigitBox
     
     
         public void clignoter(){
     
    	if(çaNeClignotePas){
                 çaNeClignotePas=false;
                 cligne = new Clignoteur();
                 cligne.start();
     
             }
             else{
                 cligne.arret();
                 çaNeClignotePas=true;
             }
     
         }//fin clignoter
     
     
    }//fin de class DigitBox
     
     
     
     
    class Clignoteur extends Thread{
     
         private boolean tantQuOnVeutClignoter
     
         public clignoteur(){
     
            creation du clignoteur...
     
            tantQuOnVeutClignoter=true;
     
         }//fin Clignoteur
     
        public void run(){
     
             while(tantQuOnVeutClignoter){
    		instruction pour clignoter
             }
     
        }//fin de run()
     
     
        public void arret(){
     
             tantQuOnVeutClignoter=false;
     
        }//fin arret
     
    }//fin de class Clignoteur
    j'ai la meme chose pour faire defiler, avec un Defileur , une methode faireDefiler...

    Il me suffit de remplacer:

    class Clignoteur extend Thread
    par
    class Clignoteur implement Runnable


    private Clignoteur cligne;
    par
    private Thread cligne;

    et
    cligne = new Clignoteur();
    cligne.start();
    par
    cligne = new Thread(new Clignoteur());
    cligne.start;

    pour etre bon ?
    Du coup je ne vois pas trop la différence....

    merci pour votre aide.
    kerinel

Discussions similaires

  1. Vérifier que les Threads se ferment bien
    Par oc_alex86 dans le forum Concurrence et multi-thread
    Réponses: 2
    Dernier message: 13/05/2007, 20h46
  2. Les Threads... J'en remet une couche :)
    Par Higestromm dans le forum C++
    Réponses: 5
    Dernier message: 17/11/2004, 12h19
  3. Gestion des message windows dans les threads
    Par billyboy dans le forum Windows
    Réponses: 5
    Dernier message: 06/10/2003, 17h25
  4. Question simple sur les threads :)
    Par momox dans le forum C++Builder
    Réponses: 2
    Dernier message: 15/06/2003, 04h13
  5. question sur les variables globales et les thread posix
    Par souris_sonic dans le forum POSIX
    Réponses: 5
    Dernier message: 13/06/2003, 13h59

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo