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