AtomicStampedReference、AtomicMarkableReference源码分析，解决cas ABA问题

cas的ABA问题就是 假设初始值为A，线程3和线程1都获取到了初始值A，然后线程1将A改为了B，线程2将B又改回了A，这时候线程3做修改时，是感知不到这个值从A改为了B又改回了A的过程：

AtomicStampedReference 本质是有一个int 值作为版本号，每次更改前先取到这个int值的版本号，等到修改的时候，比较当前版本号与当前线程持有的版本号是否一致，如果一致，则进行修改，并将版本号+1（当然加多少或减多少都是可以自己定义的），在zookeeper中保持数据的一致性也是用的这种方式；

AtomicMarkableReference则是将一个boolean值作是否有更改的标记，本质就是它的版本号只有两个，true和false，修改的时候在这两个版本号之间来回切换，这样做并不能解决ABA的问题，只是会降低ABA问题发生的几率而已；

看下面这个例子里面有主要源码的解析：

import java.util.concurrent.atomic.AtomicMarkableReference;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 解决atomic类cas操作aba问题，解决方式是在更新时设置版本号的方式来解决，每次更新就要设置一个不一样的版本号，修改的时候，不但要比较值有没有变，还要比较版本号对不对，这个思想在zookeeper中也有体现；
 * @author Administrator
 *
 */
public class AtomicStampedReferenceTest {

	public final static AtomicStampedReference<String> ATOMIC_REFERENCE = new AtomicStampedReference<String>("abc", 0);

	/**
	 *
	它里面只有一个成员变量,要做原子更新的对象会被封装为Pair对象，并赋值给pair；
	private volatile Pair<V> pair;
	
	先看它的一个内部类Pair ，要进行原子操作的对象会被封装为Pair对象
	private static class Pair<T> {
        final T reference;     //要进行原子操作的对象
        final int stamp;       //当前的版本号
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) { //该静态方法会在AtomicStampedReference的构造方法中被调用，返回一个Pair对象；
            return new Pair<T>(reference, stamp);
        }
    }
	现在再看构造方法就明白了，就是将原子操作的对象封装为pair对象
	public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }
           
           获取版本号    
           就是返回成员变量pair的stamp的值       
    public int getStamp() {
        return pair.stamp;
    }
	
            原子修改操作，四个参数分别是旧的对象，将要修改的新的对象，原始的版本号，新的版本号
            这个操作如果成功就会将expectedReference修改为newReference，将版本号expectedStamp修改为newStamp；
	public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        
        return
            expectedReference == current.reference && expectedStamp == current.stamp //如果原子操作的对象没有更改，并且版本号也没有更改， 
            &&
            (
            	(newReference == current.reference &&newStamp == current.stamp) //如果要修改的对象与就的对象相同，并且新的版本号也与旧的版本号相同，也就是重复操作，这时候什么也不干
            	||
             	casPair(current, Pair.of(newReference, newStamp)) //cas操作，生成一个新的Pair对象，替换掉旧的，修改成功返回true，修改失败返回false；
             );
    }
	 * @param args
	 */
	public static void main1(String[] args) {
		for (int i = 0; i < 100; i++) {
			final int num = i;
			final int stamp = ATOMIC_REFERENCE.getStamp();
			new Thread() {
				public void run() {
					try {
						Thread.sleep(Math.abs((int) (Math.random() * 100)));
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					if (ATOMIC_REFERENCE.compareAndSet("abc", "abc2", stamp, stamp + 1)) {
						System.out.println("我是线程：" + num + ",我获得了锁进行了对象修改！");
					}
				}
			}.start();
		}
		new Thread() {
			public void run() {
				int stamp = ATOMIC_REFERENCE.getStamp();
				while (!ATOMIC_REFERENCE.compareAndSet("abc2", "abc", stamp, stamp + 1))
					;
				System.out.println("已经改回为原始值！");
			}
		}.start();
	}
	
	
	/**AtomicMarkableReference 解决aba问题，注意，它并不能解决aba的问题 ，它是通过一个boolean来标记是否更改，本质就是只有true和false两种版本来回切换，只能降低aba问题发生的几率，并不能阻止aba问题的发生，看下面的例子**/
	public final static AtomicMarkableReference<String> ATOMIC_MARKABLE_REFERENCE = new AtomicMarkableReference<String>("abc" , false);
	
	public static void main(String[] args){
		//假设以下操作由不同线程执行
		System.out.println("mark:"+ATOMIC_MARKABLE_REFERENCE.isMarked()); //线程1 获取到mark状态为false，原始值为“abc”
		boolean thread1 = ATOMIC_MARKABLE_REFERENCE.isMarked();
		System.out.println("mark:"+ATOMIC_MARKABLE_REFERENCE.isMarked()); //线程3获取到mark状态为false ，原始值为“abc”
		boolean thread2 = ATOMIC_MARKABLE_REFERENCE.isMarked();
		System.out.println("change result:"+ATOMIC_MARKABLE_REFERENCE.compareAndSet("abc", "abc2", thread1, !thread1)); //线程1 更改abc为abc2
		
		System.out.println("mark:"+ATOMIC_MARKABLE_REFERENCE.isMarked()); //线程2获取到mark状态为true ，原始值为“abc2”
		boolean thread3 = ATOMIC_MARKABLE_REFERENCE.isMarked();
		System.out.println("change result:"+ATOMIC_MARKABLE_REFERENCE.compareAndSet("abc2", "abc", thread3, !thread3));//线程2 更改abc2为abc
		
		System.out.println("change result:"+ATOMIC_MARKABLE_REFERENCE.compareAndSet("abc", "abc2", thread2, !thread2));//线程3更改abc为abc2；
		//按照上面的执行顺序，3此修改都修改成功了，线程1与线程2拿到的mark状态都是false，他俩要做的操作都是将“abc”更改为“abc2”， 只是线程2在线程1和线程3中间做了一次更改，最后线程2做操作的时候并没有感知到线程1与线程3的更改；
	}
	
}