Java线程CAS原子操作

这次分享一些关于原子操作(CAS)的东西.

定义

CAS(Compare And Swap)是CPU的一个指令级别的操作，叫原子操作，原子操作是不可分割的，跟事务差不多，要么全部执行完成，要么不执行；

像这种操作有点类似阻塞锁机制，但是使用阻塞锁机制去控制的话，会比较消耗性能，而使用CAS操作的话会比使用锁更快。

与synchronized性能比较，最简单的一个测试Demo

public class AtomicNumber {
	
	AtomicInteger ai = new AtomicInteger(0);
	
	int i = 0;
	
	public synchronized void addInteger() {
		i ++ ;
	}
	
	public void addAtomicInteger() {
		ai.getAndIncrement();
	}
	
	public static void main(String[] args) throws InterruptedException {
		long time = System.currentTimeMillis();
		final AtomicNumber atomicNumber = new AtomicNumber();
		final CountDownLatch latch = new CountDownLatch(2);
		int count = 0;
		while(count<2) {
			new Thread(new Runnable() {
				public void run() {
					for(int j=0;j<200000;j++)
						atomicNumber.addAtomicInteger();
					latch.countDown();
				}
				
			}).start();
			count++;
		}
		latch.await();
		System.out.println("花费的时间："+(System.currentTimeMillis()-time) + "ms");
		System.out.println("atomicInteger value:"+atomicNumber.ai.get());
		final CountDownLatch latch1 = new CountDownLatch(2);
		count = 0;
		time = System.currentTimeMillis();
		while(count<2) {
			new Thread(new Runnable() {
				public void run() {
					for(int j=0;j<200000;j++)
						atomicNumber.addInteger();
					latch1.countDown();
				}
				
			}).start();
			count++;
		}
		latch1.await();
		System.out.println("花费的时间："+(System.currentTimeMillis()-time) + "ms");
		System.out.println("i value:"+atomicNumber.i);
		
	}
}

//运行的结果：
花费的时间：14ms
atomicInteger value:400000
花费的时间：35ms
i value:400000
//很明显，使用原子操作会比使用锁机制要快。

CAS里面有三个操作数：1、内存地址(V)；2、期望的值(A)；3、新值(B)

主要思想：如果内存地址V的期望值等于A时，则将地址V赋值给新值B，如果不相等，算CAS操作失败则不做任何操作；但触发了CAS操作，如果内存地址上的值V不等于A的话，就会进入死循环，一直做CAS操作，一直到相等也就是成功，这个循环过程叫自旋。

存在的问题

1、ABA问题：即当取出内存地址V的时候，期望值从A变成新值B，然后有从B变成A值，然后再将V与期望值相比发现一值，其实这个过程确实发生了变化，只是结果值与初始值一致；

像这样的问题，我们可以采用两个方式，第一种就是在期望值变化的时候加上一个版本号(AtomicStampedReference)从A1变成B2变成A3这样就能解决这样的问题了，另外一种就是变化了就标记期望值已变化(AtomicMarkableReference)。

2、开销比较大：长期处于自旋的CAS操作，会导致性能消耗。

3、只能保证只有一个共享变量进行原子操作，在Java中有个专门处理的类来解决这个问题(AtomicReference)

JDK提供的原子操作类

AtomicInteger

用法在上面的那个案例有了就不多说了，有几个需要注意的地方：

1、在使用自增的方法有两个：1）、getAndIncrement() 这个是先获取值，在自增。2）、incrementAndGet() 先自增然后在获取值。这两个方法的差别有点类似 i++ 以及 ++i的操作。

AtomicReference

这个是原子操作引用类型，结果来看，原子引用并不会改变原始的值。

    static AtomicReference<UserInfo> reference = new AtomicReference<UserInfo>();
	
	public static void main(String[] args) {
		UserInfo userInfo1 = new UserInfo("Mark",12);
		reference.set(userInfo1);
		UserInfo userInfo2 = new UserInfo("Mark12",23);
		reference.compareAndSet(userInfo1, userInfo2);
		System.out.println("new data:");
		System.out.println(reference.get().getName());
		System.out.println(reference.get().getAge());
		System.out.println("old reference object:");
		System.out.println(userInfo1.getName());
		System.out.println(userInfo1.getAge());
	}
	
	
	static class UserInfo {
		String name;
		Integer age;
		
		public UserInfo(String name, Integer age) {
			super();
			this.name = name;
			this.age = age;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public Integer getAge() {
			return age;
		}
		public void setAge(Integer age) {
			this.age = age;
		}
		
	}

//运行结果：
new data:
Mark12
23
old reference object:
Mark
12

AtomicStampedReference

在期望值变化的时候加上一个版本号，在做CAS操作的时候，如果不一致会返回为false，并且不会做任何操作

	/**
	 * <p>需要一个初始值以及初始版本号
	 */
	static AtomicStampedReference<String> reference = new AtomicStampedReference<String>("Java",0);
	
	public static void main(String[] args) throws InterruptedException {
		final String value = reference.getReference();
		final int stamp = reference.getStamp();
		System.out.println("value:" + value + "====== version:"+stamp);
		
		Thread correctThread = new Thread(new Runnable() {

			public void run() {
				System.out.println(Thread.currentThread().getName() + " old reference:"+value + " version:"+stamp + 
						" CAS STATUS : " + reference.compareAndSet(value, value + " is the beast Language", stamp, 1));
				System.out.println(Thread.currentThread().getName() + "value:" + reference.getReference() + "====== version:"+reference.getStamp());
			}
			
		});
		Thread errorThread = new Thread(new Runnable() {

			public void run() {
				System.out.println(Thread.currentThread().getName() + " old reference:"+reference.getReference() + " version:"+reference.getStamp() + 
						" CAS STATUS : " + reference.compareAndSet(value, value + " Hello World!!", stamp, 2));
				System.out.println(Thread.currentThread().getName() + "value:" + reference.getReference() + "====== version:"+reference.getStamp());
			}
			
		});
		correctThread.start();
		correctThread.join();
		errorThread.start();
		errorThread.join();
		System.out.println("value:" + reference.getReference() + "====== version:"+reference.getStamp());
	}

//运行结果：
value:Java====== version:0
value:Java====== version:0
Thread-0 old reference:Java version:0 CAS STATUS : true
Thread-1 old reference:Java version:0 CAS STATUS : false
Thread-0value:Java is the beast Language====== version:1
Thread-1value:Java is the beast Language====== version:1

目前就这么多啦，至于AtomicMarkableReference这个原子引用大家了自己去试一下跟AtomicStampedReference差不多，好啦该洗洗睡了。