Lucker пишет:
настаиваю на не путать атомарность и потокобезопасность!

JLS, SE:17.1 Terminology and Framework
A variable is any location within a program that may be stored into. <skip> Variables are kept in a main memory that is shared by all threads. <skip> Every thread has a working memory in which it keeps its own working copy of variables that it must use or assign. As the thread executes a program, it operates on these working copies. The main memory contains the master copy of every variable. <skip> the verbs use, assign, load, store, lock, and unlock name actions that a thread can perform. The verbs read, write, lock, and unlock name actions that the main memory subsystem can perform. Each of these actions is atomic (indivisible).

class Sample {
    int a = 1, b = 2;
    void hither() {
        a = b;
    }
    void yon() {
        b = a;
    }
}

class Sample {
    int a = 1;
    void hither() {
        a++;
    }
}

class Sample {
    int a = 1, b = 7;
    void hither() {
        a++;
                b = b + a;
    }
}

class Sample {
    int a = 1;
    void hither() {
        a++;                
    }
}

Lucker пишет:
A>Я может чего не так понимаю ...

ну это всего лишь значит что при выполнении таких операций в многопоточной среде ты не получишь "неожиданного" результата, как например в случае с long-ами, где старшие байты могут быть изменены в одном потоке, младшие в другом и в результате получится не рыба не мясо.

class Sample {
    int a = 1, b = 7, c = 1;
    void hither() {
                c = b + a;
    }
}

JLS, SE:
The load, store, read, and write actions on volatile variables are atomic, even if the type of the variable is double or long.

korostoff пишет:
Вилимо потому что последовательность
загрузка volatile n1 из master memory, инкремент, сохранение нового значения n1 в master memory
само по себе не атомарно.

class TestVolatile {
   private volatile int foo = 1;

   public void up() {
     foo++;
   }
}

class TestVolatile {
   private int foo = 1;

   public synchronized void up() {
     foo++;
   }
}

A>Нужно доказать, что атомарное действие может быть не thread-safe

Atomicity guarantees ensure that when a non-long/double field is used in an expression, you will obtain either its initial value or some value that was written by some thread, but not some jumble of bits resulting from two or more threads both trying to write values at the same time. However, as seen below, atomicity alone does not guarantee that you will get the value most recently written by any thread. For this reason, atomicity guarantees per se normally have little impact on concurrent program design.

Volatile
In terms of atomicity, visibility, and ordering, declaring a field as volatile is nearly identical in effect to using a little fully synchronized class protecting only that field via get/set methods, as in:

final class VFloat {
private float value;

final synchronized void set(float f) { value = f; }
final synchronized float get() { return value; }
}


Declaring a field as volatile differs only in that no locking is involved. In particular, composite read/write operations such as the "++'' operation on volatile variables are not performed atomically.

A>Все, бейте!

public class Main implements Runnable {
    private static final int ITERATIONS = 100000;
    private static final int THREADS = 10;
    private /*volatile*/ int _counter = 0;
    private boolean _start = false;

    public static void main(String[] args) {
        Main main = new Main();
        Thread[] threads = new Thread[THREADS];
        for (int i = 0; i < THREADS; ++i) {
            threads[i] = new Thread(main);
            threads[i].start();
        }
        main.go();
        for (int i = 0; i < THREADS; ++i) {
            try {
                threads[i].join();
            } catch (InterruptedException exc) {
                throw new RuntimeException(exc);
            }
        }
        System.out.println("actual   : " + main._counter);
        System.out.println("expected : " + (ITERATIONS * THREADS));
        System.out.println("passed   : " + (main._counter == (ITERATIONS * THREADS)));
    }

    public void run() {
        barrier();
        for (int i = 0; i < ITERATIONS; ++i) {
//            synchronized(this) {
                ++_counter;
//            }
        }
    }

    private synchronized void barrier() {
        while (!_start) {
            try {
                wait();
            } catch (InterruptedException exc) {
                throw new RuntimeException(exc);
            }
        }
    }

    private synchronized void go() {
        _start = true;
        notifyAll();
    }
}

actual   : 720842
expected : 1000000
passed   : false

А>Вот здесь тоже есть разногласия в понимании JLS . Вы пишите "ВСЕ иземененные переменные", а есть мнение, что только те, к которым относиться замок. Иными словами, освобождения замка объекта приводит к записи данных объекта в общую память. А если процесс менял данные других объектов?

...if a thread is to perform an unlock action on any lock, it must first copy all assigned values in its working memory back out to main memory.

...

a lock action acts as if it flushes all variables from the thread's working memory; before use they must be assigned or loaded from main memory.

public class AtomicInteger extends Number implements java.io.Serializable { 
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe =  Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
      try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
      } catch(Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * Get the current value.
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }
  
    /**
     * Atomically set the value to the given updated value
     * if the current value <tt>==</tt> the expected value.
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
      return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    /**
     * Atomically increment by one the current value.
     * @return the previous value
     */
    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

17.7 Non-atomic Treatment of double and long

Some implementations may find it convenient to divide a single write action on a 64-bit long or double value into two write actions on adjacent 32 bit values. For efficiency's sake, this behavior is implementation specific; Java virtual machines are free to perform writes to long and double values atomically or in two parts.

For the purposes of the Java programming language memory model, a single write to a non-volatile long or double value is treated as two separate writes: one to each 32-bit half. This can result in a situation where a thread sees the first 32 bits of a 64 bit value from one write, and the second 32 bits from another write. Writes and reads of volatile long and double values are always atomic. Writes to and reads of references are always atomic, regardless of whether they are implemented as 32 or 64 bit values.

VM implementors are encouraged to avoid splitting their 64-bit values where possible. Programmers are encouraged to declare shared 64-bit values as volatile or synchronize their programs correctly to avoid possible complications.

 1:   iload_1
 2:   iconst_1
 3:   iadd
 4:   istore_1

public class C
{
    public volatile long n1;
}

  instanceOfC.n1++;

private int a = 0;
private int b = 100;
public void inc() {
   a++;
   b--;
}
public void check() {
   if (a == b) {
     // ...
   }
}

private int i;
public void thread1() {
   int t = i++;
   System.out.println("1:" + t);
}
public void thread2() {
   int t = i++;
   System.out.println("1:" + t);
}

A>private int i;
A>public void thread1() {
A>   int t = i++;
A>   System.out.println("1:" + t);
A>}
A>public void thread2() {
A>   int t = i++;
A>   System.out.println("1:" + t);
A>}
A>

When a program contains two conflicting accesses (§17.4.1) that are not ordered
by a happens-before relationship, it is said to contain a data race.

If an action x synchronizes-with a following action y, then we also have hb(x, y).

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class ThreadTest {
  private final ConcurrentHashMap<Integer, Integer> m = new ConcurrentHashMap<Integer, Integer>();
  private int i;

  public int thread1() {
    return i++;
  }

  public int thread2() {
    return i++;
  }

  public static void main(String[] args) {
    final Random r = new Random();
    final ThreadTest t = new ThreadTest();
    Thread t1 = new Thread() {
      public void run() {
        for (; ;) {
          int count = t.thread1();
          Integer has = t.m.putIfAbsent(count, 1);
          if (has != null) System.out.println("1 ("+has+") "+count);
        }
      }
    };
    t1.start();
    Thread t2 = new Thread() {
      public void run() {
        for (; ;) {
          t.thread2();
          int count = t.thread1();
          Integer has = t.m.putIfAbsent(count, 2);
          if (has != null) System.out.println("2 ("+has+") "+count);
        }
      }
    };
    t2.start();
    try {
      t1.join();
      t2.join();
    }
    catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

2 (1) 2501
2 (1) 4127
1 (1) 4128
2 (1) 4130
2 (1) 4133
1 (1) 4131
2 (1) 6318
2 (1) 7109
2 (1) 7634

1 (2) 1454
2 (1) 2257
2 (1) 2649
2 (1) 2844
2 (1) 2984
1 (2) 3186

D>actual   : 720842
D>expected : 1000000
D>passed   : false
D>

int a = b++;

int c = a + b;
int d = a + b;

public class Main implements Runnable {
   private static final int ITERATIONS = 1000;
   private static final int THREADS = 100;
   private /*volatile*/ int counter = 0;

   public static void main(String[] args) {
      Main main = new Main();
      Thread[] threads = new Thread[THREADS];
      for (int i = 0; i < threads.length; i++) {
         threads[i] = new Thread(main);
         threads[i].start();
      }

      for (int i = 0; i < ITERATIONS; i++) {
         int old = main.counter;
         
         // Wait until all threads dead
         for (Thread thread = getActiveThread(threads); thread != null; thread = getActiveThread(threads)) {
            synchronized (main) {
               // Release waiting threads
               main.notifyAll();
            }
         }

         // Start again (keep waiting)
         if (i < ITERATIONS - 1) {
            for (int j = 0; j < threads.length; j++) {
               threads[j] = new Thread(main);
               threads[j].start();
            }
         }

         if (old + THREADS != main.counter) {
            System.out.println("fault on iteration " + i + ": " + (main.counter - old) + " increments missed");
         }
      }
      System.out.println("actual   : " + main.counter);
      System.out.println("expected : " + (ITERATIONS * THREADS));
      System.out.println("passed   : " + (main.counter == (ITERATIONS * THREADS)));
   }

   private static Thread getActiveThread(Thread[] threads) {
      for (int i = 0; i < threads.length; i++) {
         Thread thread = threads[i];
         if (thread.isAlive()) {
            return thread;
         }
      }
      return null;
   }

   public void run() {
      freeze();
      counter++;
   }

   private synchronized void freeze() {
      try {
         wait();
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
}

public class Main implements Runnable {
   private static final int ITERATIONS = 100;
   private static final int THREADS = 100;
   private /*volatile*/ int counter = 0;
   private boolean keepWaiting = true;

   public static void main(String[] args) {
      Main main = new Main();

      Thread[] threads = new Thread[THREADS];
      for (int i = 0; i < threads.length; i++) {
         threads[i] = new Thread(main);
         threads[i].start();
      }

      for (int i = 0; i < ITERATIONS; i++) {
         int old = main.counter;

         synchronized (main) {
            // Release waiting threads
            main.keepWaiting = false;
            main.notifyAll();
         }

         // Wait until all threads dead
         for (Thread thread = getActiveThread(threads); thread != null; thread = getActiveThread(threads)) {
            synchronized (main) {
               try {
                  System.out.println("waiting threads on iteration " + i + ": active threads - " + Thread.activeCount());
                  main.wait(1);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
         }

         synchronized (main) {
            main.keepWaiting = true;
            // Start again (keep waiting)
            if (i < ITERATIONS - 1) {
               for (int j = 0; j < threads.length; j++) {
                  threads[j] = new Thread(main);
                  threads[j].start();
               }
            }
         }
         if (old + THREADS != main.counter) {
            System.out.println("fault on iteration " + i + ": " + (main.counter - old) + " increments missed");
         }
      }
      System.out.println("actual   : " + main.counter);
      System.out.println("expected : " + (ITERATIONS * THREADS));
      System.out.println("passed   : " + (main.counter == (ITERATIONS * THREADS)));
   }

   private static Thread getActiveThread(Thread[] threads) {
      for (int i = 0; i < threads.length; i++) {
         Thread thread = threads[i];
         if (thread.isAlive()) {
            return thread;
         }
      }
      return null;
   }

   public void run() {
      synchronized (this) {
         try {
            if (keepWaiting) {
               wait();
            }
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
      counter++;
   }

}

А>Правда ли это?

this.a = 50;
this.b = 45;

synchronized (new Object) {
} // memory barrier

synchronized (new Object) {
} // memory barrier

int resA = this.a
int resB = this.b;

IA-32 Intel® Architecture Software Developer’s Manual

CHAPTER 3 INSTRUCTION SET REFERENCE, A-M
. . .
INC—Increment by 1

Adds 1 to the destination operand, while preserving the state of the CF flag. The destination
operand can be a register or a memory location. . . .

This instruction can be used with a LOCK prefix to allow the instruction to be executed atomically.

lock inc mem

inc mem

inc mem