atomicc(atomicinteger 用法)

java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，
这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。
使用原子类，性能高效，线程安全。

原子型Integer，可以实现原子更新操作

public AtomicInteger () 
初始化一个默认值为0的原子型Integer

public AtomicInteger (int initialValue) 
初始化一个指定值的原子型Integer

int get()	
获取值

int getAndIncrement() 
以原子方式将当前值加1，先取再加；自增1

int incrementAndGet() 
以原子方式将当前值加1，先加再取；先增1

int addAndGet (int data) 
以原子方式将输入的数值与实例中的值相加，先增加一个量值。

int getAndset(int value) 
以原子方式设置为newValue的值，并返回旧值。

public class VolatileAtomicDemo03 {
    public static void main(String[] args) {
        Runnable target = new MyRunnable03();
        for(int i = 1 ; i <=100;i++){
            //启动100个线程，执行100次任务
            new Thread(target).start();
        }
    }
}

class MyRunnable03 implements Runnable{
    //创建一个integer更新的原子类，默认值为0
    private AtomicInteger atomicInteger = new AtomicInteger();

    //一次任务是一个整体，加100
    @Override
    public void run() {
            for (int i = 1 ; i <=100;i++){
                System.out.println(atomicInteger.incrementAndGet());
            }
    }
}

结果是10000，可用原子类保证线程安全

先比较再交换，如果比较一致，则作废。

CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别?

Synchronized是从悲观的角度出发：
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿，这个数据就会阻塞直到它拿到锁。
共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。
因此Synchronized我们也将其称之为悲观锁。
jdk中的ReentrantLock也是一种悲观锁。 性能较差。CAS是从乐观的角度出发：
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。
CAS这种机制我们也可以将其称之为乐观锁。综合性能较好。