Чому i ++ не є атомним?

Чому i++в Java не є атомним?

Щоб трохи глибше зрозуміти Java, я спробував підрахувати, як часто виконується цикл у потоках.

Тому я використав a

private static int total = 0;

в основному класі.

У мене дві нитки.

• Нитка 1: Відбитки System.out.println("Hello from Thread 1!");
• Нитка 2: Відбитки System.out.println("Hello from Thread 2!");

І я рахую рядки, надруковані ниткою 1 і ниткою 2. Але рядки нитки 1 + рядки нитки 2 не відповідають загальній кількості роздрукованих рядків.

Ось мій код:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

    private static int total = 0;
    private static int countT1 = 0;
    private static int countT2 = 0;
    private boolean run = true;

    public Test() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        newCachedThreadPool.execute(t1);
        newCachedThreadPool.execute(t2);
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        run = false;
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println((countT1 + countT2 + " == " + total));
    }

    private Runnable t1 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT1++;
                System.out.println("Hello #" + countT1 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    private Runnable t2 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT2++;
                System.out.println("Hello #" + countT2 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    public static void main(String[] args) {
        new Test();
    }
}

i++, ймовірно, не є атомним у Java, оскільки атомність - це особлива вимога, яка відсутня у більшості застосувань i++. Ця вимога має значні накладні витрати: існує велика вартість виготовлення атомної операції приросту; вона передбачає синхронізацію як на програмному, так і на апаратному рівнях, які не повинні бути присутніми із звичайним кроком.

Ви можете навести аргумент, який i++повинен був бути розроблений і задокументований як спеціально виконуючий атомний приріст, так що неатомний приріст виконується за допомогою i = i + 1. Однак це порушить "культурну сумісність" між Java та C і C ++. Крім того, це забрало б зручне позначення, яке програмісти, знайомі з мовами, подібними до С, сприймають як належне, надаючи йому особливого значення, яке застосовується лише за обмежених обставин.

Основний код C або C ++ як for (i = 0; i < LIMIT; i++)би перекладається на Java як for (i = 0; i < LIMIT; i = i + 1); бо було б недоцільно використовувати атомний i++. Гірше того, що програмісти, що надходять із мови C або інших мов, подібних до мови C, i++все одно використовують , що призведе до непотрібного використання атомних інструкцій.

Навіть на рівні набору машинних інструкцій операція типу збільшення зазвичай не є атомарною з міркувань продуктивності. У x86 для використання incатомарної інструкції повинна використовуватися спеціальна інструкція "префікс блокування" : з тих самих причин, що і вище. Якби incвони завжди були атомними, їх ніколи б не використовували, коли потрібен неатомний розряд; програмісти та компілятори генеруватимуть код, який завантажується, додає 1 і зберігає, оскільки це буде набагато швидше.

У деяких архітектурах набору інструкцій атомних incабо, можливо, взагалі немає inc; щоб зробити атомний розряд на MIPS, вам потрібно написати програмний цикл, який використовує llі sc: зв'язане з навантаженням, і умовне зберігання. Load-linked читає слово, а умовно зберігає нове значення, якщо слово не змінилося, або воно не вдається (що виявляється та викликає повторну спробу).

i++ передбачає дві операції:

1. прочитати поточне значення i
2. збільшити значення і призначити його i

Коли два потоки виконують i++одну і ту ж змінну одночасно, вони обидва можуть отримати одне і те ж поточне значення i, а потім збільшити і встановити його i+1, так що ви отримаєте одне збільшення замість двох.

Приклад:

int i = 5;
Thread 1 : i++;
           // reads value 5
Thread 2 : i++;
           // reads value 5
Thread 1 : // increments i to 6
Thread 2 : // increments i to 6
           // i == 6 instead of 7

Важливим є JLS (специфікація мови Java), а не те, як різні реалізації JVM можуть реалізовувати певну функцію мови, а можуть і не реалізовувати її. JLS визначає оператор постфіксу ++ у пункті 15.14.2, в якому сказано, що "значення 1 додається до значення змінної і сума зберігається назад у змінній". Ніде не згадується і не натякається на багатопоточність або атомність. Для них JLS забезпечує нестабільність та синхронізацію . Крім того, існує пакет java.util.concurrent.atomic (див. Http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html )

Чому i ++ не є атомним у Java?

Давайте розбиємо операцію збільшення на кілька операторів:

Потоки 1 і 2:

1. Отримати значення загальної кількості з пам'яті
2. Додайте до значення 1
3. Перепишіть у пам’ять

Якщо синхронізації немає, то скажімо, що "Thread one" прочитав значення 3 і збільшив його до 4, але не записав його назад. На цьому етапі відбувається перемикання контексту. Потік два читає значення 3, збільшує його, і відбувається перемикання контексту. Незважаючи на те, що обидва потоки збільшили загальне значення, воно все одно буде 4 - расовим станом.

i++ це твердження, яке просто включає 3 операції:

1. Зчитати поточне значення
2. Напишіть нове значення
3. Зберігати нове значення

Ці три операції не призначені для виконання за один крок, або іншими словами, i++це не складна операція. В результаті всілякі речі можуть піти не так, коли в одній, але несполученій операції бере участь більше одного потоку.

Розглянемо такий сценарій:

Час 1 :

Thread A fetches i
Thread B fetches i

Час 2 :

Thread A overwrites i with a new value say -foo-
Thread B overwrites i with a new value say -bar-
Thread B stores -bar- in i

// At this time thread B seems to be more 'active'. Not only does it overwrite 
// its local copy of i but also makes it in time to store -bar- back to 
// 'main' memory (i)

Час 3 :

Thread A attempts to store -foo- in memory effectively overwriting the -bar- 
value (in i) which was just stored by thread B in Time 2.

Thread B has nothing to do here. Its work was done by Time 2. However it was 
all for nothing as -bar- was eventually overwritten by another thread.

І ось у вас це є. Стан перегонів.

Ось чому i++не є атомним. Якби це було, нічого з цього не сталося, і кожне fetch-update-storeвідбулося б атомно. Це саме те, що AtomicIntegerпризначено, і у вашому випадку це, мабуть , точно впишеться.

PS

Відмінна книга, що висвітлює всі ці питання, а потім і деякі з них: Конкурс Java на практиці

У JVM приріст включає читання та запис, тому він не є атомним.

Якщо операція i++буде атомною, ви не зможете прочитати з неї значення. Це саме те, що ви хочете зробити, використовуючи i++(а не використовуючи ++i).

Наприклад, подивіться на наступний код:

public static void main(final String[] args) {
    int i = 0;
    System.out.println(i++);
}

У цьому випадку ми очікуємо, що результат буде: 0 (оскільки ми публікуємо приріст, наприклад, спочатку читаємо, а потім оновлюємо)

Це одна з причин, чому операція не може бути атомарною, оскільки вам потрібно прочитати значення (і щось з ним зробити), а потім оновити значення.

Інша важлива причина полягає в тому, що виконання атомарних дій зазвичай займає більше часу через блокування. Було б безглуздо, якби всі операції з примітивами займали трохи більше часу в тих рідкісних випадках, коли люди хочуть мати атомні операції. Ось чому вони додали до мови AtomicIntegerта інші атомні класи.

Є два кроки:

1. отримати я з пам'яті - -
2. встановіть i + 1 на i

так що це не атомна операція. Коли thread1 виконує i ++, а thread2 виконує i ++, кінцевим значенням i може бути i + 1.

Паралельність ( Threadклас і подібні) є додатковою функцією у версії 1.0 Java . i++був доданий у бета-версію до цього, і як такий він все ще з більшою ймовірністю у своїй (більш-менш) оригінальній реалізації.

Синхронізація змінних залежить від програміста. Ознайомтеся з підручником Oracle щодо цього .

Редагувати: Для уточнення, i ++ - це чітко визначена процедура, яка передує Java, і, таким чином, дизайнери Java вирішили зберегти оригінальну функціональність цієї процедури.

Оператор ++ було визначено в B (1969), який передує Java і потоковує лише трохи.