CAS介绍

i++多线程问题

package com.mine.juc.cas;

public class IncrementDemo {
	private static int temp = 1;

	public static void main(String[] args) {
		System.out.println("=====i++多线程问题=====");

		new Thread(new Runnable() {

			public void run() {
				for (int i = 0; i < 100; i++) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(temp++);
				}
			}
		}).start();

		new Thread(new Runnable() {

			public void run() {
				for (int i = 0; i < 100; i++) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(temp++);
				}
			}
		}).start();
	}

}

使用原子类解决i++问题

package com.mine.juc.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerDemo {
	private static AtomicInteger atomicInt = new AtomicInteger(1);

	public static void main(String[] args) {
		System.out.println("=====原子类解决i++多线程问题=====");

		new Thread(new Runnable() {

			public void run() {
				for (int i = 0; i < 100; i++) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("AtomicInteger值为：" + atomicInt.getAndIncrement());
				}
			}
		}).start();

		new Thread(new Runnable() {

			public void run() {
				for (int i = 0; i < 100; i++) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("AtomicInteger值为：" + atomicInt.getAndIncrement());
				}
			}
		}).start();
	}

}

什么是CAS

CAS，全称为Compare and Swap，即比较-替换。
假设有三个操作数：内存值V、旧的预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，才会将内存值修改为B并返true，否则什么都不做并返回false。当然CAS一定要volatile变量配合，这样才能保证每次拿到的变量是主内存中最新的那个值，否则旧的预期值A对某条线程来说，永远是一个不会变的值A，只要某次CAS操作失败，永远都不可能成功。

CAS 有什么缺陷，如何解决？

ABA 问题
并发环境下，假设初始条件是A，去修改数据时，发现是A就会执行修改。但是看到的虽然是A，中间可能发生了A变B，B又变回A的情况。此时A已经非彼A，数据即使成功修改，也可能有问题。
可以通过AtomicStampedReference「解决ABA问题」，它一个带有标记的原子引用类，通过控制变量值的版本来保证CAS的正确性。

package com.mine.juc.cas;

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

public class ABADemo {
	private static AtomicReference<Integer> atomicReference = new AtomicReference<Integer>(100);
	private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<Integer>(100, 1);

	public static void main(String[] args) {
		System.out.println("=====CAS的ABA问题=====");
		
		System.out.println("第一次更新：" + atomicReference.compareAndSet(100, 105));
		System.out.println("第二次更新：" + atomicReference.compareAndSet(105, 100));
		
		new Thread(new Runnable() {

			public void run() {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("第三次更新：" + atomicReference.compareAndSet(100, 1000));
				System.out.println("更新后的值为：" + atomicReference.get());
			}
		}).start();
		
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("=====AtomicStampedReference解决CAS的ABA问题=====");
		System.out.println("第一次更新：" + atomicStampedReference.compareAndSet(100, 105, 1, 2));
		System.out.println("第二次更新：" + atomicStampedReference.compareAndSet(105, 100, 2, 3));
		
		new Thread(new Runnable() {

			public void run() {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("第三次更新：" + atomicStampedReference.compareAndSet(100, 1000, 1, 2));
				System.out.println("更新后的值为：" + atomicStampedReference.getReference() + "，版本号为：" + atomicStampedReference.getStamp());
			}
		}).start();
	}

}

循环时间长开销
自旋CAS，如果一直循环执行，一直不成功，会给CPU带来非常大的执行开销。很多时候，CAS思想体现，是有个自旋次数的，就是为了避开这个耗时问题。

只能保证一个变量的原子操作
CAS 保证的是对一个变量执行操作的原子性，如果对多个变量操作时，CAS 目前无法直接保证操作的原子性的。
可以通过这两个方式解决这个问题：

• 使用互斥锁来保证原子性；
• 将多个变量封装成对象，通过AtomicReference来保证原子性。