Почему этот класс не является потокобезопасным?

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

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

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

Может ли кто-нибудь объяснить, почему вышеуказанный класс не является потокобезопасным?

Поскольку это incrementметод, staticон будет синхронизироваться с объектом класса для ThreadSafeClass. decrementМетод не является статическим и синхронизировать экземпляр используется для его вызова. То есть они будут синхронизироваться на разных объектах, и, таким образом, два разных потока могут выполнять методы одновременно. Так как ++и --операции не являются атомарными класс не поточно.

Кроме того, поскольку countis static, изменение его метода decrementсинхронизированного экземпляра небезопасно, поскольку его можно вызывать в разных экземплярах и countодновременно изменять таким образом.

У вас есть два синхронизированных метода, но один из них статический, а другой - нет. При доступе к синхронизированному методу, в зависимости от его типа (статический или нестатический), другой объект будет заблокирован. Для статического метода блокировка будет помещена на объект Class, в то время как для нестатического блока блокировка будет помещена в экземпляр класса, который запускает метод. Поскольку у вас есть два разных заблокированных объекта, у вас может быть два потока, которые одновременно изменяют один и тот же объект.

Может ли кто-нибудь объяснить, почему вышеуказанный класс не является потокобезопасным?

• increment будучи статическим, синхронизация будет выполняться в самом классе.
• decrementбудучи не статическим, синхронизация будет выполняться при создании экземпляра объекта, но это ничего не защищает, поскольку countстатично.

Я хотел бы добавить, что для объявления поточно-безопасного счетчика я считаю, что самый простой способ - использовать AtomicIntegerвместо примитивного int.

Позвольте мне перенаправить вас к информации о java.util.concurrent.atomicпакете.

Другие ответы довольно хорошо объясняют причину. Я просто резюмирую 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();

synchronizedвключен fun1и fun2синхронизируется на уровне экземпляра объекта. synchronizedon fun4синхронизируется на уровне объекта класса. Что значит:

1. Когда 2 потока вызывают a1.fun1()одновременно, последний вызов будет заблокирован.
2. При одновременном вызове потока 1 a1.fun1()и потока 2 a1.fun2()последний вызов будет заблокирован.
3. Когда поток 1 вызывает a1.fun1()и поток 2 вызывает a1.fun3()одновременно, без блокировки, 2 метода будут выполняться одновременно.
4. Когда нить 1 звонок A.fun4(), если другие потоки называют A.fun4()или A.fun5()в то же время, последние вызовы будут заблокированы , так как synchronizedна одном fun4уровне класса.
5. Когда поток 1 вызывает вызов A.fun4()потока 2 a1.fun1()одновременно, без блокировки, 2 метода будут выполняться одновременно.

1. decrementблокирует другой объект, incrementчтобы они не мешали друг другу работать.
2. Вызов decrementодного экземпляра блокирует другое, чем вызов decrementдругого экземпляра, но они влияют на одно и то же.

Первый означает, что перекрывающиеся вызовы incrementи decrementмогут привести к отмене (правильной), увеличению или уменьшению.

Второе означает, что два перекрывающихся вызова в decrementразных экземплярах могут привести к двойному (правильному) или единственному уменьшению.

Поскольку два разных метода, один - это уровень экземпляра, а другой - уровень класса, поэтому вам нужно заблокировать 2 разных объекта, чтобы сделать его ThreadSafe

Как объясняется в других ответах, ваш код не является потокобезопасным, поскольку статический метод increment()блокирует монитор классов, а нестатический метод decrement()блокирует монитор объектов.

Для этого примера кода существует лучшее решение без synchronzedиспользования ключевых слов. Вы должны использовать AtomicInteger для обеспечения безопасности потоков.

Потокобезопасное использование 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();
    }

}