Чому цей клас не є безпечним для потоків?

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

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

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

Хто-небудь може пояснити, чому вищезгаданий клас не є безпечним для потоків?

Оскільки incrementметод є, staticвін буде синхронізуватися з об'єктом класу для ThreadSafeClass. decrementМетод не є статичним і синхронізувати екземпляр використовується для його виклику. Тобто, вони будуть синхронізуватися на різних об’єктах, і, отже, два різні потоки можуть виконувати методи одночасно. Оскільки операції ++and --не є атомними, клас не є безпечним для потоку.

Крім того, оскільки countє 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. Коли a1.fun1()одночасно дзвонять 2 потоки , останній дзвінок буде заблокований.
2. Коли виклик потоку 1 a1.fun1()і потік 2 дзвінка a1.fun2()одночасно, останній виклик буде заблокований.
3. Коли виклик потоку 1 a1.fun1()і виклик потоку 2 a1.fun3()одночасно, без блокування, 2 методи будуть виконуватися одночасно.
4. Коли виклик потоку 1 A.fun4(), якщо викликають інші потоки A.fun4()або A.fun5()одночасно, останні виклики будуть заблоковані, оскільки synchronizedon 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();
    }

}