线程安全之如何实现多线程下的自增安全

package com.ilucky.test.jdk.util.concurrent;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 线程安全: 当多个线程访问某个类时, 这个类始终都能表现出正确的行为, 那么就称这个类是线程安全的。
 * @author IluckySi
 *
 */
public class ThreadSafeTest {

       public static int count = 0;
       public static Counter counter = new Counter();
       public static AtomicInteger atomicInteger = new AtomicInteger(0);
       volatile public static int countVolatile = 0;

    public static void main(String[] args) {
        // 保证所有线程执行完毕.
        final CountDownLatch cdl = new CountDownLatch(10);
        for(int i=0; i<10; i++) {
             new Thread() {
                 public void run() {
                     for (int j = 0; j < 1000; j++) {
                         count++;
                         counter.increment();
                         atomicInteger.getAndIncrement();
                         countVolatile++;
                    }
                    cdl.countDown();
                 }
             }.start();
        }
        try {
            cdl.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("static count: " + count);
        System.out.println("Counter: " + counter.getValue());
        System.out.println("AtomicInteger: " + atomicInteger.intValue());
        System.out.println("countVolatile: " + countVolatile);
    }
}

class Counter {

    private int value;

    public synchronized int getValue() {
        return value;
    }

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

    public synchronized int decrement() {
        return --value;
    }
}
/**
运行结果如下，每次运行结果都不一样，但是每次中间的两个都是10000.
static count: 9997
Counter: 10000
AtomicInteger: 10000
countVolatile: 9997

说明要解决自增操作在多线程环境下线程不安全的问题，可以选择使用Java提供的原子类或者使用synchronized同步方法。
而使用volatile关键字, 并不能解决非原子操作的线程安全性。
另外: 虽然递增操作++i看上去只是一个操作, 但这个操作并非原子的, 因而它并不会作为一个不可分割的操作来执行。
实际上它包含了三个独立的操作: 读取count的值, 将值加1, 然后将计算结果写入count. 
这是一个“读取 - 修改 - 写入”的操作序列, 并且其结果状态依赖于之前的状态。

补充:
volatile变量具有synchronized的可见性特性, 但是不具备原子特性。
volatile变量可用于提供线程安全, 但是应用场景非常局限: 多个变量之间或者某个变量的当前值与修改后值之间没有约束。
因此, 单独使用volatile还不足以实现计数器、互斥锁或任何具有与多个变量相关的不变式.
 */