J'ai une donnée (de type String) partagée entre plusieurs Thread.
Je fais donc quelque chose du genre:
class DonneePartagee
{
private String _valeur = "";
public void set(String v) { _valeur = v;}
public String get() { return _valeur ;}
}
Et la forcement se pose la question des accès simultanés.
Je rajoute donc des synchronized:
class DonneePartagee
{
private String _valeur = "";
public synchronized void set(String v) { _valeur = v;}
public synchronized String get() { return _valeur ;}
}
Mais je me demande si c'est bien nécéssaire.
La classe String étant non modifiable ( on peut remplacer une String par
une autre mais pas modifier le contenu de l'objet), pour un peu que
l'affectation ( le = ) soit atomique ( la tache ne peut pas être
preemptée à ce moment) , je n'aurais même pas besoin de rajouter des
synchronized.
Les affectations (objet à objet) sont elles atomiques ?
Les affectations des types simple ( boolean,short,int,double) sont elles
atomiques ( là j'ai plus de doutes car il peux y avoir des cast si on
affecte des types différents par exemple un short dans un double).
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Hervé AGNOUX
Je n'ai pas réussi à retrouver les références, alors je te dis juste ce que j'avais calé dans ma tête sur ces questions.
En java il est impossible, de garantir la protection contre les accés concurrents d'une portion de code, sauf avec synchronized, y compris pour les variables et les situations les plus simples.
La seule exception est le chargement et l'initialisation statique d'une classe, en ce sens que on a la garantie qu'une classe est entièrement chargée et initialisée avant d'être utilisée. Donc, tu peux utiliser une classe depuis plusieurs threads à la fois sans te préoccuper de savoir quel est le premier qui la charge, toute son initialisation statique se passera sans anicroches, ce qui est déjà un sérieux soucis de moins !
Pour ton cas précis, de set et de get avec affectation d'une seule variable, il ne faut penser à le synchroniser que si tu es en environnement multi-processeur. Néanmoins, même en environnement mono-processeur, rien n'est garanti, car tu peux te retrouver sur un "vieil" environnement où les références d'objet sont codées sur une unité plus large que l'unité d'accés du processeur.
Pour ma part, dans le cas qui est le tiens, je ne synchroniserai pas. Je ne synchronise que si il y a une séquence d'instructions java, ce qui est une erreur, mais erreur raisonnable :-)
Tu pourras trouver d'autres précisisions sur ces forums si tu parles anglais :
J'ai une donnée (de type String) partagée entre plusieurs Thread.
Je fais donc quelque chose du genre:
class DonneePartagee { private String _valeur = "";
public void set(String v) { _valeur = v;} public String get() { return _valeur ;} }
Et la forcement se pose la question des accès simultanés.
Je rajoute donc des synchronized: class DonneePartagee { private String _valeur = "";
public synchronized void set(String v) { _valeur = v;} public synchronized String get() { return _valeur ;} }
Mais je me demande si c'est bien nécéssaire. La classe String étant non modifiable ( on peut remplacer une String par une autre mais pas modifier le contenu de l'objet), pour un peu que l'affectation ( le = ) soit atomique ( la tache ne peut pas être preemptée à ce moment) , je n'aurais même pas besoin de rajouter des synchronized.
Les affectations (objet à objet) sont elles atomiques ? Les affectations des types simple ( boolean,short,int,double) sont elles atomiques ( là j'ai plus de doutes car il peux y avoir des cast si on affecte des types différents par exemple un short dans un double).
Merci.
-- Hervé AGNOUX http://www.diaam-informatique.com
Je n'ai pas réussi à retrouver les références, alors je te dis juste ce que
j'avais calé dans ma tête sur ces questions.
En java il est impossible, de garantir la protection contre les accés
concurrents d'une portion de code, sauf avec synchronized, y compris pour
les variables et les situations les plus simples.
La seule exception est le chargement et l'initialisation statique d'une
classe, en ce sens que on a la garantie qu'une classe est entièrement
chargée et initialisée avant d'être utilisée. Donc, tu peux utiliser une
classe depuis plusieurs threads à la fois sans te préoccuper de savoir quel
est le premier qui la charge, toute son initialisation statique se passera
sans anicroches, ce qui est déjà un sérieux soucis de moins !
Pour ton cas précis, de set et de get avec affectation d'une seule variable,
il ne faut penser à le synchroniser que si tu es en environnement
multi-processeur. Néanmoins, même en environnement mono-processeur, rien
n'est garanti, car tu peux te retrouver sur un "vieil" environnement où les
références d'objet sont codées sur une unité plus large que l'unité d'accés
du processeur.
Pour ma part, dans le cas qui est le tiens, je ne synchroniserai pas. Je ne
synchronise que si il y a une séquence d'instructions java, ce qui est une
erreur, mais erreur raisonnable :-)
Tu pourras trouver d'autres précisisions sur ces forums si tu parles
anglais :
J'ai une donnée (de type String) partagée entre plusieurs Thread.
Je fais donc quelque chose du genre:
class DonneePartagee
{
private String _valeur = "";
public void set(String v) { _valeur = v;}
public String get() { return _valeur ;}
}
Et la forcement se pose la question des accès simultanés.
Je rajoute donc des synchronized:
class DonneePartagee
{
private String _valeur = "";
public synchronized void set(String v) { _valeur = v;}
public synchronized String get() { return _valeur ;}
}
Mais je me demande si c'est bien nécéssaire.
La classe String étant non modifiable ( on peut remplacer une String par
une autre mais pas modifier le contenu de l'objet), pour un peu que
l'affectation ( le = ) soit atomique ( la tache ne peut pas être
preemptée à ce moment) , je n'aurais même pas besoin de rajouter des
synchronized.
Les affectations (objet à objet) sont elles atomiques ?
Les affectations des types simple ( boolean,short,int,double) sont elles
atomiques ( là j'ai plus de doutes car il peux y avoir des cast si on
affecte des types différents par exemple un short dans un double).
Je n'ai pas réussi à retrouver les références, alors je te dis juste ce que j'avais calé dans ma tête sur ces questions.
En java il est impossible, de garantir la protection contre les accés concurrents d'une portion de code, sauf avec synchronized, y compris pour les variables et les situations les plus simples.
La seule exception est le chargement et l'initialisation statique d'une classe, en ce sens que on a la garantie qu'une classe est entièrement chargée et initialisée avant d'être utilisée. Donc, tu peux utiliser une classe depuis plusieurs threads à la fois sans te préoccuper de savoir quel est le premier qui la charge, toute son initialisation statique se passera sans anicroches, ce qui est déjà un sérieux soucis de moins !
Pour ton cas précis, de set et de get avec affectation d'une seule variable, il ne faut penser à le synchroniser que si tu es en environnement multi-processeur. Néanmoins, même en environnement mono-processeur, rien n'est garanti, car tu peux te retrouver sur un "vieil" environnement où les références d'objet sont codées sur une unité plus large que l'unité d'accés du processeur.
Pour ma part, dans le cas qui est le tiens, je ne synchroniserai pas. Je ne synchronise que si il y a une séquence d'instructions java, ce qui est une erreur, mais erreur raisonnable :-)
Tu pourras trouver d'autres précisisions sur ces forums si tu parles anglais :
J'ai une donnée (de type String) partagée entre plusieurs Thread.
Je fais donc quelque chose du genre:
class DonneePartagee { private String _valeur = "";
public void set(String v) { _valeur = v;} public String get() { return _valeur ;} }
Et la forcement se pose la question des accès simultanés.
Je rajoute donc des synchronized: class DonneePartagee { private String _valeur = "";
public synchronized void set(String v) { _valeur = v;} public synchronized String get() { return _valeur ;} }
Mais je me demande si c'est bien nécéssaire. La classe String étant non modifiable ( on peut remplacer une String par une autre mais pas modifier le contenu de l'objet), pour un peu que l'affectation ( le = ) soit atomique ( la tache ne peut pas être preemptée à ce moment) , je n'aurais même pas besoin de rajouter des synchronized.
Les affectations (objet à objet) sont elles atomiques ? Les affectations des types simple ( boolean,short,int,double) sont elles atomiques ( là j'ai plus de doutes car il peux y avoir des cast si on affecte des types différents par exemple un short dans un double).
Merci.
-- Hervé AGNOUX http://www.diaam-informatique.com
TestMan
Bonjour,
J'ai une donnée (de type String) partagée entre plusieurs Thread.
Je fais donc quelque chose du genre:
class DonneePartagee { private String _valeur = "";
public void set(String v) { _valeur = v;} public String get() { return _valeur ;} }
Et la forcement se pose la question des accès simultanés.
Je rajoute donc des synchronized: class DonneePartagee { private String _valeur = "";
public synchronized void set(String v) { _valeur = v;} public synchronized String get() { return _valeur ;} }
Mais je me demande si c'est bien nécéssaire. La classe String étant non modifiable ( on peut remplacer une String par une autre mais pas modifier le contenu de l'objet), pour un peu que l'affectation ( le = ) soit atomique ( la tache ne peut pas être preemptée à ce moment) , je n'aurais même pas besoin de rajouter des synchronized.
Les affectations (objet à objet) sont elles atomiques ? Les affectations des types simple ( boolean,short,int,double) sont elles atomiques ( là j'ai plus de doutes car il peux y avoir des cast si on affecte des types différents par exemple un short dans un double).
Merci.
Bonjour,
Tout dépend du JIT utilisé et de la configuration matérielle sur laquelle on se trouve, il me semble que sous HotSpot c'est atomique ... mais je ne trouve plus mon lien.
Pour faire plus simple, si l'on veut des choses atomiques, il vaut mieux utiliser : java.util.concurrent.atomic
Plus de lecture sur : http://www.cs.umd.edu/~daveho/research/ecoop2002.pdf
A+
TM
Bonjour,
J'ai une donnée (de type String) partagée entre plusieurs Thread.
Je fais donc quelque chose du genre:
class DonneePartagee
{
private String _valeur = "";
public void set(String v) { _valeur = v;}
public String get() { return _valeur ;}
}
Et la forcement se pose la question des accès simultanés.
Je rajoute donc des synchronized:
class DonneePartagee
{
private String _valeur = "";
public synchronized void set(String v) { _valeur = v;}
public synchronized String get() { return _valeur ;}
}
Mais je me demande si c'est bien nécéssaire.
La classe String étant non modifiable ( on peut remplacer une String par
une autre mais pas modifier le contenu de l'objet), pour un peu que
l'affectation ( le = ) soit atomique ( la tache ne peut pas être
preemptée à ce moment) , je n'aurais même pas besoin de rajouter des
synchronized.
Les affectations (objet à objet) sont elles atomiques ?
Les affectations des types simple ( boolean,short,int,double) sont elles
atomiques ( là j'ai plus de doutes car il peux y avoir des cast si on
affecte des types différents par exemple un short dans un double).
Merci.
Bonjour,
Tout dépend du JIT utilisé et de la configuration matérielle sur
laquelle on se trouve, il me semble que sous HotSpot c'est atomique ...
mais je ne trouve plus mon lien.
Pour faire plus simple, si l'on veut des choses atomiques, il vaut mieux
utiliser :
java.util.concurrent.atomic
Plus de lecture sur :
http://www.cs.umd.edu/~daveho/research/ecoop2002.pdf
J'ai une donnée (de type String) partagée entre plusieurs Thread.
Je fais donc quelque chose du genre:
class DonneePartagee { private String _valeur = "";
public void set(String v) { _valeur = v;} public String get() { return _valeur ;} }
Et la forcement se pose la question des accès simultanés.
Je rajoute donc des synchronized: class DonneePartagee { private String _valeur = "";
public synchronized void set(String v) { _valeur = v;} public synchronized String get() { return _valeur ;} }
Mais je me demande si c'est bien nécéssaire. La classe String étant non modifiable ( on peut remplacer une String par une autre mais pas modifier le contenu de l'objet), pour un peu que l'affectation ( le = ) soit atomique ( la tache ne peut pas être preemptée à ce moment) , je n'aurais même pas besoin de rajouter des synchronized.
Les affectations (objet à objet) sont elles atomiques ? Les affectations des types simple ( boolean,short,int,double) sont elles atomiques ( là j'ai plus de doutes car il peux y avoir des cast si on affecte des types différents par exemple un short dans un double).
Merci.
Bonjour,
Tout dépend du JIT utilisé et de la configuration matérielle sur laquelle on se trouve, il me semble que sous HotSpot c'est atomique ... mais je ne trouve plus mon lien.
Pour faire plus simple, si l'on veut des choses atomiques, il vaut mieux utiliser : java.util.concurrent.atomic
Plus de lecture sur : http://www.cs.umd.edu/~daveho/research/ecoop2002.pdf
