import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;


public class AtomicTests {
  private static final int threadCount = 10;
  private static final int iterationsPerThread = 100;
  
  public static void main(String[] args) {
    runAtomicIntegerTest(true);
    runAtomicIntegerTest(false);
    
    runAtomicLongTest(true);
    runAtomicLongTest(false);
    
    runAtomicReferenceTest();
  }
  
  private static void blockTillThreadsDone(AtomicInteger threadDoneCount) throws InterruptedException {
    synchronized (threadDoneCount) {
      while (threadDoneCount.get() < threadCount) {
        threadDoneCount.wait();
      }
    }
  }
  
  private static void runAtomicIntegerTest(final boolean increment) {
    final AtomicInteger result = new AtomicInteger();
    final AtomicInteger threadDoneCount = new AtomicInteger();
    // only using an AtomicBoolean here so I don't need two variables to do the synchronize/wait/notify
    final AtomicBoolean threadsStart = new AtomicBoolean(false);
    
    Runnable operationRunnable = new Runnable() {
      @Override
      public void run() {
        boolean flip = true;
        for (int i = 0; i < iterationsPerThread; i++) {
          if (flip) {
            if (increment) {
              result.incrementAndGet();
            } else {
              result.decrementAndGet();
            }
            flip = false;
          } else {
            if (increment) {
              result.getAndIncrement();
            } else {
              result.getAndDecrement();
            }
            flip = true;
          }
        }
      }
    };
    
    for (int i = 0; i < threadCount; i++) {
      new Thread(new DelayedRunnable(threadsStart, 
                                     operationRunnable, 
                                     threadDoneCount)).start();
    }
    
    synchronized (threadsStart) {
      threadsStart.set(true);
      
      threadsStart.notifyAll();
    }
    
    try {
      blockTillThreadsDone(threadDoneCount);
    } catch (InterruptedException e) {
      // let thread exit
      return;
    }
    
    int expectedResult = threadCount * iterationsPerThread;
    if (! increment) {
      expectedResult *= -1;
    }
    int resultValue = result.get();
    if (resultValue != expectedResult) {
      throw new IllegalStateException(resultValue + " != " + expectedResult);
    }
  }
  
  private static void runAtomicLongTest(final boolean increment) {
    final AtomicLong result = new AtomicLong();
    final AtomicInteger threadDoneCount = new AtomicInteger();
    // only using an AtomicBoolean here so I don't need two variables to do the synchronize/wait/notify
    final AtomicBoolean threadsStart = new AtomicBoolean(false);
    
    Runnable operationRunnable = new Runnable() {
      @Override
      public void run() {
        boolean flip = true;
        for (int i = 0; i < iterationsPerThread; i++) {
          if (flip) {
            if (increment) {
              result.incrementAndGet();
            } else {
              result.decrementAndGet();
            }
            flip = false;
          } else {
            if (increment) {
              result.getAndIncrement();
            } else {
              result.getAndDecrement();
            }
            flip = true;
          }
        }
      }
    };
    
    for (int i = 0; i < threadCount; i++) {
      new Thread(new DelayedRunnable(threadsStart, 
                                     operationRunnable, 
                                     threadDoneCount)).start();
    }
    
    synchronized (threadsStart) {
      threadsStart.set(true);
      
      threadsStart.notifyAll();
    }
    
    try {
      blockTillThreadsDone(threadDoneCount);
    } catch (InterruptedException e) {
      // let thread exit
      return;
    }
    
    long expectedResult = threadCount * iterationsPerThread;
    if (! increment) {
      expectedResult *= -1;
    }
    long resultValue = result.get();
    if (resultValue != expectedResult) {
      throw new IllegalStateException(resultValue + " != " + expectedResult);
    }
  }
  
  private static void runAtomicReferenceTest() {
    final AtomicReference<Integer> result = new AtomicReference<Integer>(0);
    final AtomicInteger threadDoneCount = new AtomicInteger(0);
    // only using an AtomicBoolean here so I don't need two variables to do the synchronize/wait/notify
    final AtomicBoolean threadsStart = new AtomicBoolean(false);
    
    Runnable operationRunnable = new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i < iterationsPerThread; i++) {
          Integer current = result.get();
          while (! result.compareAndSet(current, current + 1)) {
            current = result.get();
          }
        }
      }
    };
    
    for (int i = 0; i < threadCount; i++) {
      new Thread(new DelayedRunnable(threadsStart, 
                                     operationRunnable, 
                                     threadDoneCount)).start();
    }
    
    synchronized (threadsStart) {
      threadsStart.set(true);
      
      threadsStart.notifyAll();
    }
    
    try {
      blockTillThreadsDone(threadDoneCount);
    } catch (InterruptedException e) {
      // let thread exit
      return;
    }
    
    long expectedResult = threadCount * iterationsPerThread;
    Integer resultValue = result.get();
    if (resultValue != expectedResult) {
      throw new IllegalStateException(resultValue + " != " + expectedResult);
    }
  }
  
  private static class DelayedRunnable implements Runnable {
    private final AtomicBoolean threadsStart;
    private final Runnable operationRunnable;
    private final AtomicInteger threadDoneCount;
    
    private DelayedRunnable(AtomicBoolean threadsStart, 
                            Runnable operationRunnable, 
                            AtomicInteger threadDoneCount) {
      this.threadsStart = threadsStart;
      this.operationRunnable = operationRunnable;
      this.threadDoneCount = threadDoneCount;
    }
    
    @Override
    public void run() {
      try {
        try {
          waitTillReady();
        } catch (InterruptedException e) {
          // let thread exit
          return;
        }
        operationRunnable.run();
      } finally {
        synchronized (threadDoneCount) {
          threadDoneCount.incrementAndGet();
          
          threadDoneCount.notifyAll();
        }
      }
    }
    
    private void waitTillReady() throws InterruptedException {
      synchronized (threadsStart) {
        while (! threadsStart.get()) {
          threadsStart.wait();
        }
      }
    }
  }
}