实现CAS的方法（JUC，mysql数据库，缓存redis）

目录

1. JUC并发包自带的原子操作类

2.  基于mysql的实现

3. 基于缓存的实现

---

简单解释：CAS操作需要输入两个数值，一个旧值（期望操作前的值）和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。CAS操作是原子性的，所以多线程并发使用CAS更新数据时，可以不使用锁。JDK中大量使用了CAS来更新数据而防止加锁（synchronized 重量级锁）来保持原子更新。

1. JUC并发包自带的原子操作类

例如：AtomicInteger类

源码分析：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    static {
        try {
            //用于获取value字段相对当前对象的“起始地址”的偏移量
            valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    //返回当前值
    public final int get() {
        return value;
    }

    //递增加detla
    public final int getAndAdd(int delta) {
        //三个参数，1、当前的实例 2、value实例变量的偏移量 3、当前value要加上的数（value+delta）。
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

    //递增加1
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
...
}

我们看它的主要方法，即增加的方法，都是调用了 unsafe的getAndAddInt()方法的。

public final int getAndAddInt(Object paramObject, long paramLong, int paramInt)
  {
    int i;
    do
      i = getIntVolatile(paramObject, paramLong);
    while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));
    return i;
  }

其实上面这个方法就代表了CAS的基本逻辑了。 do-while 表示自旋过程，compareAndSwapInt就是CAS了，如果CAS不成功，就继续自旋(继续循环)，若CAS成功，就会把 i 换成 i+paramInt

 

2.  基于mysql的实现

基于mysql通过版本号实现。必须要给数据库的表加一个version字段。因为用CAS的情况下，还得避免ABA问题。

然后在代码层面，SQL语句如下：

更新数据之前，需要先获取版本号，然后用版本号来更新数据

// 秒杀服务，修改库存
public boolean updateGoodAmount(String code,int buys){
    //获取商品库存对象
    TGoodsInfo info = mapper.selectByPrimaryKey(code);
    //获取商品库存
    Integer amount = info.getAmount();

    //如果库存不够则返回
    if(amount<buys) return false;

    //获取版本号
    Integer version = info.getVersion();
    //带上版本号更新库存
    if(mapper.updateAmountByVersion(code,buys,version)>0){
        return true;
    }
    //如果更新失败，当前线程随机休眠
    waitForLock();
    //递归调用本身
    return updateGoodAmount(code,buys);
}

private void waitForLock(){
    try{
        Thread.sleep(new Random().nextInt(10)+1);
    }catch(InterruptedException e){
        e.printStackTrace();
    }
}

从上面代码可以看到，若更新失败（即上一刻获取的版本号跟数据库里的版本号不一致，意味着有其他线程修改过数据），则该线程随机休眠一段时间，为什么要随机休眠，是因为可以到达流量的削峰填谷的作用，把瞬时大流量平摊到后面的时间中。 最后递归调用本身，达到一个循环的效果，来实现自旋的功能。

但是这种做法对效率的提升也不会特别高，因为只要是直接修改数据库，那么就意味着，是对IO进行操作，众所周知，IO速度是很慢的，所以这个时候实现CAS，相比于加重量级锁synchronized，效率不会提升太多。

 

3. 基于缓存的实现

以redis为例：

redis主要基于watch命令来实现CAS乐观锁。

 

Redis事务
Redis中的事务(transaction)是一组命令的集合。事务同命令一样都是Redis最小的执行单位，一个事务中的命令要么都执行，要么都不执行。Redis事务的实现需要用到 MULTI 和 EXEC 两个命令，事务开始的时候先向Redis服务器发送 MULTI 命令，然后依次发送需要在本次事务中处理的命令，最后再发送 EXEC 命令表示事务命令结束。

Redis的事务是下面4个命令来实现 

1.multi，开启Redis的事务，置客户端为事务态。
2.exec，提交事务，执行从multi到此命令前的命令队列，置客户端为非事务态。
3.discard，取消事务，置客户端为非事务态。
4.watch,监视键值对，作用时如果事务提交exec时发现监视的监视对发生变化，事务将被取消。

下面结合 Jedis 来实现一个秒杀的例子代码：

代码出处：https://blog.csdn.net/Evankaka/article/details/70570200?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

package com.github.distribute.lock.redis;
 
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
 
/**
 * redis乐观锁实例 
 * @author linbingwen
 *
 */
public class OptimisticLockTest {
 
	public static void main(String[] args) throws InterruptedException {
		 long starTime=System.currentTimeMillis();
		
		 initPrduct();
		 initClient();
		 printResult();
		 
		long endTime=System.currentTimeMillis();
		long Time=endTime-starTime;
		System.out.println("程序运行时间： "+Time+"ms");   
 
	}
	
	/**
	 * 输出结果
	 */
	public static void printResult() {
		Jedis jedis = RedisUtil.getInstance().getJedis();
		Set<String> set = jedis.smembers("clientList");
 
		int i = 1;
		for (String value : set) {
			System.out.println("第" + i++ + "个抢到商品，"+value + " ");
		}
 
		RedisUtil.returnResource(jedis);
	}
 
	/*
	 * 初始化顾客开始抢商品
	 */
	public static void initClient() {
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		int clientNum = 10000;// 模拟客户数目
		for (int i = 0; i < clientNum; i++) {
			cachedThreadPool.execute(new ClientThread(i));
		}
		cachedThreadPool.shutdown();
		
		while(true){  
	            if(cachedThreadPool.isTerminated()){  
	                System.out.println("所有的线程都结束了！");  
	                break;  
	            }  
	            try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}    
	        }  
	}
 
	/**
	 * 初始化商品个数
	 */
	public static void initPrduct() {
		int prdNum = 100;// 商品个数
		String key = "prdNum";
		String clientList = "clientList";// 抢购到商品的顾客列表
		Jedis jedis = RedisUtil.getInstance().getJedis();
 
		if (jedis.exists(key)) {
			jedis.del(key);
		}
		
		if (jedis.exists(clientList)) {
			jedis.del(clientList);
		}
 
		jedis.set(key, String.valueOf(prdNum));// 初始化
		RedisUtil.returnResource(jedis);
	}
 
}
 
/**
 * 顾客线程
 * 
 * @author linbingwen
 *
 */
class ClientThread implements Runnable {
	Jedis jedis = null;
	String key = "prdNum";// 商品主键
	String clientList = "clientList"; 抢购到商品的顾客列表主键
	String clientName;
 
	public ClientThread(int num) {
		clientName = "编号=" + num;
	}
 
	public void run() {
		try {
			Thread.sleep((int)(Math.random()*5000));// 随机睡眠一下
		} catch (InterruptedException e1) {
		}
		while (true) {
			System.out.println("顾客:" + clientName + "开始抢商品");
			jedis = RedisUtil.getInstance().getJedis();
			try {
				jedis.watch(key);
				int prdNum = Integer.parseInt(jedis.get(key));// 当前商品个数
				if (prdNum > 0) {
					Transaction transaction = jedis.multi();
					transaction.set(key, String.valueOf(prdNum - 1));
					List<Object> result = transaction.exec();
					if (result == null || result.isEmpty()) {
						System.out.println("悲剧了，顾客:" + clientName + "没有抢到商品");// 可能是watch-key被外部修改，或者是数据操作被驳回
					} else {
						jedis.sadd(clientList, clientName);// 抢到商品记录一下
						System.out.println("好高兴，顾客:" + clientName + "抢到商品");
						break;
					}
				} else {
					System.out.println("悲剧了，库存为0，顾客:" + clientName + "没有抢到商品");
					break;
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				jedis.unwatch();
				RedisUtil.returnResource(jedis);
			}
 
		}
	}
 
}

运行结果：

和上文的使用悲观锁相比，乐观锁的实现更加的简单，并发性能也会更好。