原子操作CAS

CAS原理

CAS（Compare And Swap），指令级别保证这时一个原子操作

三个运算符：一个内存地址V，一个期望的值A，一个新值B
基本思路：如果地址V上的值和期望值A相等，就给地址V赋值给新值B，如果不是，不做任何操作（循环自旋不断进行CAS操作）

CAS问题

• ABA问题：A—》B—》A，内存地址V最后的值确实为A，但在中途发生过改变，却并不知道，可以使用版本号解决
• 开销问题：CAS操作长期不成功，CPU不断的循环
• 只能保证一个共享变量的原子操作

AtomicInteger的使用：

public class UseAtomicInt {
	
	static AtomicInteger ai = new AtomicInteger(10);
	
    public static void main(String[] args) {
    	System.out.println(ai.getAndIncrement());//10--->11
    	System.out.println(ai.incrementAndGet());//11--->12--->out
    	System.out.println(ai.get());
    }
}

【执行结果】

10
12
12

AtomicReference的使用：

public class UseAtomicReference {
	
	static AtomicReference<UserInfo> userRef = new AtomicReference<UserInfo>();
	
    public static void main(String[] args) {
        UserInfo user = new UserInfo("Mark", 15);//要修改的实体的实例
        userRef.set(user);
        
        UserInfo updateUser = new UserInfo("Bill", 17);//要变化的新实例
        //注意这里比较的是引用，只要user引用指向的对象不变，CAS就会成功
        //（即user里面的字段发生改变，CAS也会成功）
        userRef.compareAndSet(user, updateUser);
        System.out.println(userRef.get().getName());
        System.out.println(userRef.get().getAge());
        System.out.println(user.getName());
        System.out.println(user.getAge());        
    }
    
    //定义一个实体类
    static class UserInfo {
        private String name;
        private int age;
        public UserInfo(String name, int age) {
            this.name = name;
            this.age = age;
        }
       // getter and setter ... 
    }
}

【执行结果】

Bill
17
Mark
15

解决ABA问题的原子操作类：

• AtomicMarkableReference 使用boolean判断地址V的值有没有动过
• AtomicStampedRefernece 使用版本号记录地址V的值动过几次

public class UseAtomicStampedReference {
	
	static AtomicStampedReference<String> asr = 
			new AtomicStampedReference<>("Mark",0);
	

    public static void main(String[] args) throws InterruptedException {
    	final int oldStamp = asr.getStamp();//那初始的版本号
    	final String oldReferenc = asr.getReference();
    	
    	System.out.println(oldReferenc+"==========="+oldStamp);
    	
    	Thread rightStampThread = new Thread(new Runnable() {

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()
						+"当前变量值："+oldReferenc+"当前版本戳："+oldStamp+"-"
						+asr.compareAndSet(oldReferenc, oldReferenc+"Java",
								oldStamp, oldStamp+1));
			}
    	});
    	
    	Thread errorStampThread = new Thread(new Runnable() {

			@Override
			public void run() {
				String reference = asr.getReference();
				System.out.println(Thread.currentThread().getName()
						+"当前变量值："+reference+"当前版本戳："+asr.getStamp()+"-"
						+asr.compareAndSet(reference, reference+"C",
								oldStamp, oldStamp+1));
			}
    	});   	
    	
    	rightStampThread.start();
    	rightStampThread.join();
    	errorStampThread.start();
    	errorStampThread.join();
    	System.out.println(asr.getReference()+"==========="+asr.getStamp());
    }
}

【执行结果】

Mark===========0
Thread-0当前变量值： Mark当前版本戳： 0-true
Thread-1当前变量值： MarkJava当前版本戳： 1-false
MarkJava===========1

AtomicIntegerArray原子类操作数组的使用：

public class AtomicArray {
    static int[] value = new int[] { 1, 2 };
    
    static AtomicIntegerArray ai = new AtomicIntegerArray(value);
    
    public static void main(String[] args) {
    	ai.getAndSet(0, 3);
    	System.out.println(ai.get(0));
    	System.out.println(value[0]);

    }
}

【执行结果】

3
1