2.1 Actomic类和乐观锁

该类实现了原子性操作。

CAS -->compare and set ，乐观锁 实现，并未有真正的锁

这种乐观锁和synchronized 不同，并没有将线程阻塞，而是通过各个线程不停地循环，判断版本号是否与之前相同，从而进行更新操作。

t1和t2两个线程同时去进行++操作，t1获取了最新版本号1，进行update操作时候v1 ==v0 （假设此时t2还未接入）,v0=2，a=4执行update操作；而此时t2 介入，之前t2 读取了v0=1和value ，v0!=v2此时不能进行update操作，所以要重新读取a=4,v=2，此时再进行update，还是比较v2==0,执行update，a=5，v0=3；

package com.caolh.base;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;



public class DemoThread14 implements Runnable{
	
	public static /*volatile*/ AtomicInteger sum = new AtomicInteger(0);
	
	public static void add(){
		System.out.println(Thread.currentThread().getName()+"初始sum="+sum);
		for(int i=0;i<10000;i++){
			//sum++;
			sum.addAndGet(1);
		}
		System.out.println(Thread.currentThread().getName()+"计算后sum="+sum);
	}
	
	@Override
	public void run() {
		add();
	}
	
	public static void main(String[] args) {
		//如果volatile具有原子性,那么10个线程并发调用，最终结果应该为100000
		ExecutorService es = Executors.newFixedThreadPool(10);
		for(int i=0;i<10;i++){
			es.submit(new DemoThread14());
		}
		es.shutdown();
		while(true){
			if(es.isTerminated()){
				System.out.println("sum最终="+sum);
				if(sum.get()==100000){
					System.out.println(sum+"=ok");
				}else{
					System.out.println(sum+"=no");
				}
				break;
			}
		}
	}
}

乐观锁的代码实现： 

 # 这点很有趣

  通过看 java 代码 

AtomicInteger 类， 这个类最终实现CAS操作，是native 方法，调用的是c语言的代码  后续 整合

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

 乐观锁有一个循环进行比较版本号的操作，这个操作的性能换取了 === synchronized 的同步锁 的性能/ 后续整合