Faire une classe Thread-Safe

Donné:

public class TestSeven extends Thread {

private static int x;

public synchronized void doThings() {
    int current = x;
    current++;
    x = current;
}

public void run() {
    doThings();
  }
}

Quel énoncé est vrai?

A. Compilation échoue.

B. Une exception est levée lors de l'exécution.

C. la Synchronisation de la méthode run() rendrait la classe thread-safe.

D. Les données dans la variable "x" sont protégées contre l'accès simultané de problèmes.

E. Déclarant la doThings() la méthode statique rendrait la classe thread-safe.

F. envelopper les instructions à l'intérieur de doThings() dans un synchronisée(new Object()) { } bloc rendrait la classe thread-safe.

n'est-ce pas assez pour marquer doThings() comme synchronisée afin de rendre cette classe Thread-safe ? je vois que la bonne réponse est D mais le Modèle de réponse à cette question est E, Mais je ne comprends pas pourquoi?

source d'informationauteur Java Player

17

E. Déclarant la doThings() la méthode statique rendrait la classe thread-safe.

C'est difficile de répondre. La méthode est déjà synchronisée, mais sur l'instance, alors que l'état est dans un champ statique, c'est à dire sur la classe. Rendant static synchronized est en effet la bonne réponse, car alors il se synchronise sur la classe, et non pas sur une (de sens) de l'instance.

D. Les données dans la variable "x" sont protégées contre l'accès simultané de problèmes.
```
private static int x;
```
C'est une variable statique. Il est partagé par toutes les instances de la classe, de la synchronisation des cas individuels n'est pas utile, de la même manière que F n'est pas utile, qui synchronise sur une poubelle objet fictif.
11

Selon la langue spec:

Une méthode synchronisée acquiert un moniteur (§17.1) avant d'exécuter.

Pour une classe de méthode (statique), le moniteur associé à la Classe
objet de la méthode de la classe est utilisée.

Pour une méthode d'instance, le moniteur associé à l'objet
pour lequel la méthode est invoquée) est utilisé.

Cela signifie que, dans le code que vous avez fourni les synchronized mot-clé causes de la méthode pour acquérir un verrou sur this avant d'exécuter le corps de la méthode. Cependant, depuis x est static qui n'a pas de s'assurer que la mise à jour de x sera atomique. (Une autre instance de la classe a pu entrer dans le synchronisée de la région et de faire une mise à jour en même temps puisqu'ils ont différents this valeurs et donc de serrures différentes.)

Cependant, déclarant doStuff statique fera tous les appels à la méthode de l'acquisition d'une même serrure (l'un sur la Class), et, donc, d'assurer l'exclusion mutuelle dans le corps de la méthode.

Le cahier des charges est vraiment orthographe que:
```
class A {
    static synchronized void doSomething() {
        //...
    }
}
```
est littéralement la même chose que
```
class A {
    static void doSomething() {
        synchronized(A.class) {
            //...
        }
    }
}
```
De la même façon:
```
class B {
    synchronized void doSomething() {
        //...
    }
}
```
est littéralement la même chose que
```
class B {
    void doSomething() {
        synchronized (this) {
            //...
        }
    }
}
```
6

Par le biais de la synchronisation de l'doThings() la méthode, vous êtes maintenant le verrou pour un particulier TestSeven objet. Cependant, les variables statiques de la classe n'appartient pas à l'instance spécifique de l'objet lui-même. Ils appartiennent à la Classe de l'objet TestSeven.class. Donc, soit vous pouvez aller faire un
```
synchronized (TestSeven.class){
    int current = x;
    current++;
    x = current;
}
```
à l'intérieur de votre doThings() méthode qui est l'acquisition de la Classe de verrouillage à l'intérieur d'une instance de verrouillage qui est trop de choses. Donc, vous pouvez marquer la méthode statique de sorte que vous finissez par acquérir le verrou de l'objet de Classe seul.
1

Depuis x est static autres threads peuvent le modifier en même temps doThings méthode est en cours d'exécution. Faire doThings static va arrêter cela.
-6

Je suis d'accord avec vous que la réponse correcte est D.
Je dirais que E est incorrecte car si j'ai mis doThings() comme statique et de supprimer le mot-clé synchronized, je ne pouvais tout simplement de démarrer à 50 TestSeven fils et il pourrait en résulter une mauvaise valeur de x.

Note:
J'ai été mal ici, j'ai raté le point de méthode synchronisée sans statique fait d'utiliser l'exemple de la serrure au lieu de surveiller la Classe elle-même.

Vous devez vous connecter pour publier un commentaire.