Pourquoi cette classe n'est-elle pas thread-safe?

class ThreadSafeClass extends Thread
{
     private static int count = 0;

     public synchronized static void increment()
     {
         count++;
     }

     public synchronized void decrement()
     {
         count--;
     }
}

Quelqu'un peut-il expliquer pourquoi la classe ci-dessus n'est pas thread-safe?

Étant donné que la incrementméthode est, staticelle se synchronisera sur l'objet de classe pour le ThreadSafeClass. La decrementméthode n'est pas statique et se synchronisera sur l'instance utilisée pour l'appeler. C'est-à-dire qu'ils se synchroniseront sur des objets différents et ainsi deux threads différents pourront exécuter les méthodes en même temps. Étant donné que les opérations ++et --ne sont pas atomiques, la classe n'est pas thread-safe.

De plus, comme countest static, en le modifiant à partir de decrementlaquelle est synchronisée instance procédé est dangereux car il peut être demandé à différentes instances et modifier en countmême temps que de cette façon.

Vous avez deux méthodes synchronisées, mais l'une d'elles est statique et l'autre non. Lors de l'accès à une méthode synchronisée, en fonction de son type (statique ou non statique), un objet différent sera verrouillé. Pour une méthode statique, un verrou sera placé sur l'objet Class, tandis que pour le bloc non statique, un verrou sera placé sur l'instance de la classe qui exécute la méthode. Étant donné que vous avez deux objets verrouillés différents, vous pouvez avoir deux threads qui modifient le même objet simultanément.

Quelqu'un peut-il expliquer pourquoi la classe ci-dessus n'est pas thread-safe?

• increment étant statique, la synchronisation se fera sur la classe elle-même.
• decrementn'étant pas statique, la synchronisation se fera sur l'instanciation de l'objet, mais cela ne sécurise rien car countc'est statique.

J'aimerais ajouter que pour déclarer un compteur thread-safe, je pense que le moyen le plus simple est d'utiliser à la AtomicIntegerplace d'un int primitif.

Laissez-moi vous rediriger vers le java.util.concurrent.atomicpackage-info.

Les réponses des autres sont assez bonnes expliquées la raison. J'ajoute juste quelque chose pour résumer synchronized:

public class A {
    public synchronized void fun1() {}

    public synchronized void fun2() {}

    public void fun3() {}

    public static synchronized void fun4() {}

    public static void fun5() {}
}

A a1 = new A();

synchronizedactivé fun1et fun2est synchronisé au niveau de l'objet d'instance. synchronizedon fun4est synchronisé au niveau de l'objet de classe. Ce qui signifie:

1. Lorsque 2 threads appellent a1.fun1()en même temps, ce dernier appel sera bloqué.
2. Lorsque le fil 1 a1.fun1()et le fil 2 appellent a1.fun2()en même temps, ce dernier appel sera bloqué.
3. Lorsque le thread 1 appelle a1.fun1()et le thread 2 appelle a1.fun3()en même temps, pas de blocage, les 2 méthodes seront exécutées en même temps.
4. Lorsque le thread 1 appelle A.fun4(), si d'autres threads appellent A.fun4()ou A.fun5()en même temps, ces derniers appels seront bloqués car synchronizedon fun4est au niveau de la classe.
5. Lorsque le thread 1 appelle A.fun4(), le thread 2 appelle a1.fun1()en même temps, pas de blocage, les 2 méthodes seront exécutées en même temps.

1. decrementse verrouille sur une chose différente incrementpour qu'ils ne s'empêchent pas de fonctionner.
2. L'appel decrementsur une instance se verrouille sur une chose différente de l'appel decrementsur une autre instance, mais ils affectent la même chose.

Le premier signifie que le chevauchement des appels à incrementet decrementpourrait entraîner une annulation (correcte), un incrément ou une diminution.

Le second signifie que deux appels qui se chevauchent decrementsur des instances différentes peuvent entraîner un double décrément (correct) ou un seul décrément.

Étant donné que deux méthodes différentes, l'une est au niveau de l'instance et l'autre au niveau de la classe, vous devez donc verrouiller 2 objets différents pour le rendre ThreadSafe

Comme expliqué dans d'autres réponses, votre code n'est pas thread-safe car la méthode statique increment()verrouille le moniteur de classe et la méthode non statique decrement()verrouille le moniteur d'objets.

Pour cet exemple de code, une meilleure solution existe sans synchronzedutilisation de mot-clé. Vous devez utiliser AtomicInteger pour assurer la sécurité des threads.

Thread safe en utilisant AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

class ThreadSafeClass extends Thread {

    private static AtomicInteger count = new AtomicInteger(0);

    public static void increment() {
        count.incrementAndGet();
    }

    public static void decrement() {
        count.decrementAndGet();
    }

    public static int value() {
        return count.get();
    }

}