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).

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

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++;
   }

}

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.

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++;
   }
}

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

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