目录
简单解释: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 来实现一个秒杀的例子代码:
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);
}
}
}
}
运行结果:
和上文的使用悲观锁相比,乐观锁的实现更加的简单,并发性能也会更好。