Por que esta classe não é thread-safe?

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

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

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

Alguém pode explicar por que a classe acima não é thread-safe?

Como o incrementmétodo é, staticele sincronizará no objeto de classe para o ThreadSafeClass. O decrementmétodo não é estático e será sincronizado na instância usada para chamá-lo. Ou seja, eles serão sincronizados em objetos diferentes e, portanto, dois threads diferentes podem executar os métodos ao mesmo tempo. Como as operações ++e --não são atômicas, a classe não é segura para threads.

Além disso, uma vez que counté static, modificá-lo a partir de decrementque é um sincronizado exemplo método não é seguro uma vez que pode ser chamado em casos diferentes e modificar countsimultaneamente dessa forma.

Você tem dois métodos sincronizados, mas um deles é estático e o outro não. Ao acessar um método sincronizado, baseado em seu tipo (estático ou não estático), um objeto diferente será bloqueado. Para um método estático, um bloqueio será colocado no objeto Class, enquanto para o bloco não estático, um bloqueio será colocado na instância da classe que executa o método. Como você tem dois objetos bloqueados diferentes, pode ter dois threads que modificam o mesmo objeto simultaneamente.

Alguém pode explicar por que a classe acima não é thread-safe?

• increment sendo estático, a sincronização será feita na própria classe.
• decrementsendo não estático, a sincronização será feita na instanciação do objeto, mas isso não protege nada como countestático.

Eu gostaria de adicionar isso para declarar um contador thread-safe, acredito que a maneira mais simples é usar em AtomicIntegervez de um int primitivo.

Deixe-me redirecioná-lo para as java.util.concurrent.atomicinformações do pacote.

As respostas dos outros são muito boas e explicam o motivo. Acabei de adicionar algo para resumir 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();

synchronizedativado fun1e fun2é sincronizado no nível do objeto de instância. synchronizedon fun4é sincronizado no nível do objeto de classe. Que significa:

1. Quando 2 threads chamam a1.fun1()ao mesmo tempo, a última chamada será bloqueada.
2. Quando o thread 1 chama a1.fun1()e o thread 2 chama a1.fun2()ao mesmo tempo, a última chamada será bloqueada.
3. Quando encadear 1 chamada a1.fun1()e encadear 2 chamadaa1.fun3() ao mesmo tempo, sem bloqueio, os 2 métodos serão executados ao mesmo tempo.
4. Quando o thread 1 chama A.fun4(), se outros threads chamam A.fun4()ou A.fun5()ao mesmo tempo, as últimas chamadas serão bloqueadas, poissynchronizedfun4 esteja no nível de classe.
5. Quando o thread 1 chama A.fun4(), o thread 2 chama a1.fun1()ao mesmo tempo, sem bloqueio, os 2 métodos serão executados ao mesmo tempo.

1. decrement é travar uma coisa diferente para increment que não impeçam um ao outro de funcionar.
2. Chamar decrementuma instância é bloquear algo diferente de chamar decrementoutra instância, mas eles estão afetando a mesma coisa.

O primeiro significa que chamadas sobrepostas para incrementedecrement podem resultar em um cancelamento (correto), um incremento ou um decremento.

O segundo significa que duas chamadas sobrepostas para decrementem instâncias diferentes podem resultar em um decréscimo duplo (correto) ou um decremento único.

Uma vez que dois métodos diferentes, um é o nível de instância e outro é o nível de classe, então você precisa bloquear 2 objetos diferentes para torná-lo ThreadSafe

Conforme explicado em outras respostas, seu código não é seguro para thread, pois o método estático increment()bloqueia o monitor de classe e o método não estáticodecrement() bloqueia o monitor de objeto.

Para este exemplo de código, existe uma solução melhor sem o synchronzeduso de palavras-chave. Você tem que usar AtomicInteger para alcançar a segurança do Thread.

Segure a linha usando 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();
    }

}