实现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);
			}
 
		}
	}
 
}

运行结果:

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值