如何模擬一個情況，當i ++被同時執行的線程破壞？

Question

如果int遞增/遞減操作在Java 6中不是原子的，也就是說，它們被分成幾步執行（讀取值，增量，寫入等），我希望看到一段代碼多個線程如何影響單個int變量，從而完全破壞整個變量。

例如，基本步驟包括但不包括所有這些： i ++〜=將i放入寄存器;增加i（增加操作）;寫回我的記憶;

如果兩個或兩個以上的線程在進程中交錯，那可能意味着對i ++的兩次後續調用後的值將只增加一次。

你可以演示一段代碼在java中，模擬多線程環境中的這種情況？

Answer 1

這是代碼。很抱歉的static，只是想節省幾行代碼，它不會影響結果：

public class Test 
{ 
    public static int value; 

    public static void main(String[] args) throws InterruptedException 
    { 
     Runnable r = new Runnable() { 
      @Override 
      public void run() { 
       for(int i = 0; i < 50000; ++i) 
        ++value; 
      } 
     }; 

     List<Thread> threads = new ArrayList<Thread>(); 
     for(int j = 0; j < 2; ++j) 
      threads.add(new Thread(r)); 
     for (Thread thread : threads) 
      thread.start(); 
     for (Thread thread : threads) 
      thread.join(); 

     System.out.println(value); 
    } 
} 

這個程序可以50000和100000之間的任何打印，但它從來沒有真正在我的機器上印刷10萬。

現在用AtomicInteger和incrementAndGet()方法替代int方法。它將始終打印100000，而不會對性能造成太大影響（它使用CPU CAS指令，不支持Java同步）。

Answer 2

public class Test { 
    private static int counter; 

    public static void main(String[] args) throws InterruptedException { 
     Runnable r = new Runnable() { 
      public void run() { 
       for (int i = 0; i < 100000; i++) { 
        counter++; 
       } 
      } 
     }; 
     Thread t1 = new Thread(r); 
     Thread t2 = new Thread(r); 
     t1.start(); 
     t2.start(); 
     t1.join(); 
     t2.join(); 
     if (counter != 200000) { 
      System.out.println("Houston, we have a synchronization problem: counter should be 200000, but it is " + counter); 
     } 
    } 
} 

運行我的機器上這個節目給

Houston, we have a synchronization problem: counter should be 200000, but it is 198459 

Answer 3

你需要爲++許多重複運行測試是快速和之前有時間有是一個問題可以運行到結束。

public static void main(String... args) throws InterruptedException { 
    for (int nThreads = 1; nThreads <= 16; nThreads*=2) 
     doThreadSafeTest(nThreads); 
} 

private static void doThreadSafeTest(final int nThreads) throws InterruptedException { 
    final int count = 1000 * 1000 * 1000; 

    ExecutorService es = Executors.newFixedThreadPool(nThreads); 
    final int[] num = {0}; 
    for (int i = 0; i < nThreads; i++) 
     es.submit(new Runnable() { 
      public void run() { 
       for (int j = 0; j < count; j += nThreads) 
        num[0]++; 
      } 
     }); 
    es.shutdown(); 
    es.awaitTermination(10, TimeUnit.SECONDS); 
    System.out.printf("With %,d threads should total %,d but was %,d%n", nThreads, count, num[0]); 
} 

打印

With 1 threads should total 1,000,000,000 but was 1,000,000,000 
With 2 threads should total 1,000,000,000 but was 501,493,584 
With 4 threads should total 1,000,000,000 but was 319,482,716 
With 8 threads should total 1,000,000,000 but was 261,092,117 
With 16 threads should total 1,000,000,000 but was 202,145,371 

只有500K我有一個基本的筆記本電腦下面。在更快的機器上，您可以在出現問題之前獲得更高的迭代次數。

With 1 threads should total 500,000 but was 500,000 
With 2 threads should total 500,000 but was 500,000 
With 4 threads should total 500,000 but was 500,000 
With 8 threads should total 500,000 but was 500,000 
With 16 threads should total 500,000 but was 500,000