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 :

Thread Safe explication


Sujet :

Concurrence et multi-thread Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Inscrit en
    Janvier 2006
    Messages
    194
    Détails du profil
    Informations personnelles :
    Âge : 43

    Informations forums :
    Inscription : Janvier 2006
    Messages : 194
    Par défaut Thread Safe explication
    Bonjour tous le monde,

    Est ce que quelqu'un à une idée sur les Thread safe [utilisation, fonctionnement]?

    Merci d'avance

  2. #2
    Rédacteur/Modérateur
    Avatar de regis1512
    Homme Profil pro
    Chef de projet NTIC
    Inscrit en
    Mai 2008
    Messages
    1 264
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Haute Vienne (Limousin)

    Informations professionnelles :
    Activité : Chef de projet NTIC
    Secteur : Industrie

    Informations forums :
    Inscription : Mai 2008
    Messages : 1 264
    Par défaut
    Bonjour,

    La notion de Thread Safe consiste à assurer qu'un objet peut être utilisé par plusieurs Thread simultané sans comportement hasardeux.

    Pour cela, on s'assure que les opérations sensibles ne peuvent être accéder que par un Thread à la fois grâce au mot clé synchronized.

    Pour plus d'informations, tu peux voir du cote du tuto : http://rom.developpez.com/java-synchronisation/

    Bon courage.
    Pourquoi cet avatar ? Parce que j'aime bien le tableau "Le Fils de l'homme" de Magritte.
    Mes contributions sur developpez.com

  3. #3
    Expert éminent
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    Avril 2002
    Messages
    13 938
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : Avril 2002
    Messages : 13 938
    Billets dans le blog
    1
    Par défaut
    Salut,

    Citation Envoyé par menzlitsh Voir le message
    Est ce que quelqu'un à une idée sur les Thread safe [utilisation, fonctionnement]?
    Les thread safe ne sont pas des objets : cela ne s'utilise pas !!!


    La notion de thread-safe est un concept, qui dit qu'une methode ou un objet peut être utilisé depuis différents threads sans que cela ne pose de problème ou de résultat incohérent selon les actions effectué par les autres threads sur l'objet ou l'application...


    Salut,

    Citation Envoyé par regis1512 Voir le message
    La notion de Thread Safe consiste à assurer qu'un objet peut être utilisé par plusieurs Thread simultané sans comportement hasardeux.
    Tout à fait !
    Si plusieurs threads manipules les même données on pourrait se retrouver dans de facheuse situation

    Un code thread-safe est un code qui permet de gérer cela, afin de s'exécuter correctement en toute circonstance.
    Bien sûr le déroulement des threads peut faire varier le résultat final, mais cela ne provoquera pas d'incohérence ni d'erreur.



    Prenons par exemple le code suivant :
    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
    class User {
     
    	private String name;
     
    	public void setName(String name) {
    		this.name = name;
    	}
     
    	public String getName() {
    		return this.name;
    	}
     
    	/**
             * @return Le nom avec la première lettre en majuscule...
             */
    	public String getFormattedName() {
    		if (this.name.length()>=1) {
    			return this.name.substring(0,1).toUpperCase() + this.name.substring(1);
    		}
    		return this.name;
    	}
     
    }
    En l'état les méthodes setName() et getName() sont thread-safe (leurs exécutions ne sont pas impacté par les modifications extérieurs sur l'objet), car les opérations d'affectation sont atomique (attention ce n'est pas vrai sur les types float/double !).

    Par contre la méthode getFormattedName() n'est pas thread-safe, car si un autre thread effectue un setName() pendant son déroulement, on peut se retrouver avec une valeur incorrect qui serait le mix des veux valeurs.

    Par exemple si quand on rentre dans la méthode getFormattedName() :
    • l'attribut name vaut "aaa", et le premier substring nous donne donc "a" puis "A".
    • Un autre thread prend la main et change la valeur de l'attribut en "bbb"
    • On reprend la main et on effectue le second substring qui donne "bb"
    • Au final on obtient "Abb" ce qui est totalement incorrect


    A noter que cela pourrait être pire, car si on fait un setName("") on pourrait générer une exception sur le substring() car on aurait déjà passé le if()


    Citation Envoyé par regis1512 Voir le message
    Pour cela, on s'assure que les opérations sensibles ne peuvent être accéder que par un Thread à la fois grâce au mot clé synchronized.
    C'est une solution. Dans mon exemple cela donnerait ceci :
    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
    class User {
     
    	private String name;
     
    	public synchronized void setName(String name) {
    		this.name = name;
    	}
     
    	public String getName() {
    		return this.name;
    	}
     
    	/**
             * @return Le nom avec la première lettre en majuscule...
             */
    	public synchronized String getFormattedName() {
    		if (this.name.length()>=1) {
    			return this.name.substring(0,1).toUpperCase() + this.name.substring(1);
    		}
    		return this.name;
    	}
     
    }
    Désormais lorsqu'on exécute getFormattedName() on ne peut plus utiliser setName() depuis un autre thread, et inversement.


    Toutefois ce n'est pas forcément la meilleure solution, car c'est assez couteux (les threads sont endormis et doivent s'attendre mutuellement). Si dans certains cas on ne peut pas l'éviter, on peut généralement s'en passer (ou limiter la durée de la synchronisation) en travaillant avec des variables locales :

    Par exemple :
    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
    class User {
     
    	private String name;
     
    	public void setName(String name) {
    		this.name = name;
    	}
     
    	public String getName() {
    		return this.name;
    	}
     
    	/**
             * @return Le nom avec la première lettre en majuscule...
             */
    	public synchronized String getFormattedName() {
    		// On travaille sur une variable locale :
    		String theName = this.name;
     
    		if (theName.length()>=1) {
    			return theName.substring(0,1).toUpperCase() + theName.substring(1);
    		}
    		return theName;
    	}
     
    }
    Désormais un setName() peut être effectué pendant getFormattedName() sans que cela ne provoque d'erreur ou de comportement incohérent




    Bref : la notion de thread-safe consiste à faire un code sécurisé en cas d'utilisation depuis différents threads, souvent via un coût dû à la synchronisation.



    a++

  4. #4
    Membre confirmé
    Inscrit en
    Janvier 2006
    Messages
    194
    Détails du profil
    Informations personnelles :
    Âge : 43

    Informations forums :
    Inscription : Janvier 2006
    Messages : 194
    Par défaut
    Je me suis trompé je voulais dire les ThreadLocal

  5. #5
    Expert éminent
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 482
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 482
    Par défaut
    c'est une variabe dont la valeur est différente pour chaque thread. Une des utilisations c'est de stocker dans la classe une valeur pour le thread courant pour la récupérer plus tard dans le traitement sans avoir à la passer en paramètre à toutes les méthodes. Une autre est de "marquer" le thread courant d'une information que tu devra reprendre dans le futur.


    D'un point de vue "logique", une ThreadLocal est proche d'un Map<Thread,Object> qui serait synchronisé, mais en pratique c'est beaucoup plus performant car la donnée est stockée non pas dans ta classe mais dans le Thread sous la forme Map<ThreadLocal,Object> (donc pas besoin de synchronisation, mais attention à bien faire un set(null) quand t'en a plus besoin)

Discussions similaires

  1. [RCP] Treeviewer non thread-safe ?
    Par Guildux dans le forum Eclipse Platform
    Réponses: 4
    Dernier message: 09/01/2007, 13h00
  2. fonction de stdio.h thread safe ??
    Par boolzor dans le forum POSIX
    Réponses: 3
    Dernier message: 30/04/2006, 20h03
  3. Code "Thread Safe" ?
    Par Neitsa dans le forum C++
    Réponses: 3
    Dernier message: 23/12/2005, 14h33
  4. [Language]Immutable & Thread-Safe
    Par Repti dans le forum Concurrence et multi-thread
    Réponses: 4
    Dernier message: 21/12/2005, 15h50
  5. [MFC] CMAP non thread safe ?
    Par fmarot dans le forum MFC
    Réponses: 5
    Dernier message: 04/10/2005, 13h21

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