Java多线程之原子性 volatile、atomicInteger、synchronized测试

Java自增操作不是原子性操作，有三步：读，增，写；

AtomicInteger:一个提供原子操作的Integer的类。 一种线程安全的加减操作接口, 相比 synchroized、lock 高效.

synchroized:可以保证多线程下原子操作，不过效率低；

volatile：关键字，只能保证可见性，无法保证对变量的任何操作都是原子性的。

public class IncrementTest {

public static int staticCounter = 0; //non-thread-safe
public static Counter synchronizedCounter = new Counter(); //synchronized
public static AtomicInteger atomicInteger = new AtomicInteger(0);
volatile public static int volatileCounter = 0; //volatile

public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 10000; j++) {
staticCounter++;
synchronizedCounter.increment();
atomicInteger.getAndIncrement();
volatileCounter++;
}
}
}.start();
}
while(Thread.activeCount()>1)  //保证前面的线程都执行完
Thread.yield();
//        try {
//            TimeUnit.SECONDS.sleep(5);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

System.out.println("non-thread-safe-> static staticCounter: " + staticCounter);
System.out.println("synchronized Counter: " + synchronizedCounter.getValue());
System.out.println("AtomicInteger: " + atomicInteger.intValue());
System.out.println("nonatomic-> volatileCounter: " + volatileCounter);
}

}

class Counter {
private int value;

public synchronized int getValue() {
return value;
}

public synchronized int increment() {
return ++value;
}

public synchronized int decrement() {
return --value;
}
}