乐观锁之CAS

1. java中的CAS是什么？

CAS是compare and swap的缩写，即我们所说的比较交换。cas是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高。
CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

2. 为什么要使用CAS?

解决高并发问题。

3.CAS使用中需要注意什么问题?

①.CAS容易造成ABA问题。一个线程a将数值改成了b，接着又改成了a，此时CAS认为是没有变化，其实是已经变化过了，而这个问题的解决方案可以使用版本号标识，每操作一次version加1。在java5中，已经提供了AtomicStampedReference来解决问题。
②.CAS造成CPU利用率增加。之前说过了CAS里面是一个循环判断的过程，如果线程一直没有获取到状态，cpu资源会一直被占用。

4. 测试java.util.concurrent.atomic.AtomicInteger提供的基于CAS机制的方法。

1. 定义变量count=0,开100个线程，每个线程加50次，结果一般来说都会小于5000.
2. 同样的方法，使用AtomicInteger提供的方法进行计算，每次结果都是5000。

代码如下

package junitTest;

import java.util.concurrent.atomic.AtomicInteger;

import org.junit.Test;

public class FwIntentionTest extends AbstractJUnit{

	private static class MyCount {
	    static int count = 0;
	    static AtomicInteger count2 = new AtomicInteger(0);
	}
	
	@Test
	public void test20() throws InterruptedException {
	    for (int i = 1; i <= 100; i++) {
	        MyThrend thrend = new MyThrend("thead" + i);
	        Thread thread = new Thread(thrend);
	        thread.start();
	    }
	    Thread.sleep(2000);
	    System.err.println("==========================="+MyCount.count+"===========================");
	    System.err.println("==========================="+MyCount.count2.get()+"===========================");
	}

	static class MyThrend implements Runnable {
	    private String name;
	    MyThrend(String threadName) {
	        this.name = threadName;
	    }

	    @Override
	    public void run() {
	        for (int i=0;i<50;i++){
	        	MyCount.count++;
	        	MyCount.count2.getAndIncrement();
	        	//MyCount.count2.getAndAdd(2);
	       }
	    }
	}

}

5. 分析AtomicInteger提供源码


AtomicInteger，AtomicLong,AtomicBoolean…都在java.util.current.atomic包下面，采用了CAS机制来实现加锁
6. ABA问题重现

private static AtomicInteger atomicInt = new AtomicInteger(100);
    
    public static void main(String[] args) throws InterruptedException {
        Thread intT1 = new Thread(new Runnable() {
            @Override
            public void run() {
                atomicInt.compareAndSet(100, 101);
                atomicInt.compareAndSet(101, 100);
            }
        });
        
        Thread intT2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                boolean c3 = atomicInt.compareAndSet(100, 101);
                System.out.println(c3);        //true,系统认为一致,无法区分
            }
        });
        
        intT1.start();
        intT2.start();
        intT1.join();
        intT2.join();
        
    }

7. ABA解决方案

private static AtomicStampedReference<Integer> atomicStampedRef = 
            new AtomicStampedReference<Integer>(100, 0);
    
    public static void main(String[] args) throws InterruptedException {
        
        Thread refT1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //多两个参数,一个版本号,一个版本号+1
                atomicStampedRef.compareAndSet(100, 101, 
                        atomicStampedRef.getStamp(), atomicStampedRef.getStamp()+1);
                atomicStampedRef.compareAndSet(101, 100, 
                        atomicStampedRef.getStamp(), atomicStampedRef.getStamp()+1);
            }
        });
        
        Thread refT2 = new Thread(new Runnable() {
            @Override
            public void run() {
                int stamp = atomicStampedRef.getStamp();
                System.out.println("before sleep : stamp = " + stamp);    // stamp = 0
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("after sleep : stamp = " + atomicStampedRef.getStamp());//stamp = 1
                boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp+1);
                System.out.println(c3);        //false,表示可以区分出来ABA问题
            }
        });
        
        refT1.start();
        refT2.start();
    }