mysql乐观锁 秒杀_Redis 乐观锁-> 秒杀抢购 案例讲解

乐观锁

大多数是基于数据版本(version)的记录机制实现的。即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个”version”字段来实现读取出数据时，将此版本号一同读出，之后更新时，对此版本号加1。此时，将提交数据的版本号与数据库表对应记录的当前版本号进行比对，如果提交的数据版本号大于数据库当前版本号，则予以更新，否则认为是过期数据。redis中可以使用watch命令会监视给定的key，当exec时候如果监视的key从调用watch后发生过变化，则整个事务会失败。也可以调用watch多次监视多个key。这样就可以对指定的key加乐观锁了。注意watch的key是对整个连接有效的，事务也一样。如果连接断开，监视和事务都会被自动清除。当然了exec，discard，unwatch命令都会清除连接中的所有监视。

Redis事务

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

1.multi，开启Redis的事务，置客户端为事务态。

2.exec，提交事务，执行从multi到此命令前的命令队列，置客户端为非事务态。

3.discard，取消事务，置客户端为非事务态。

4.watch,监视键值对，作用时如果事务提交exec时发现监视的监视对发生变化，事务将被取消。

下面简单实现一个用redis乐观锁实现的秒杀系统

代码实现：

1 packagecom.github.distribute.lock.redis;2

3 importjava.util.List;4 importjava.util.Set;5 importjava.util.concurrent.ExecutorService;6 importjava.util.concurrent.Executors;7

8 importredis.clients.jedis.Jedis;9 importredis.clients.jedis.Transaction;10

11 /**

12 * redis乐观锁实例13 *@authorlinbingwen14 *15 */

16 public classOptimisticLockTest {17

18 public static void main(String[] args) throwsInterruptedException {19 long starTime=System.currentTimeMillis();20

21 initPrduct();22 initClient();23 printResult();24

25 long endTime=System.currentTimeMillis();26 long Time=endTime-starTime;27 System.out.println("程序运行时间： "+Time+"ms");28

29 }30

31 /**

32 * 输出结果33 */

34 public static voidprintResult() {35 Jedis jedis =RedisUtil.getInstance().getJedis();36 Set set = jedis.smembers("clientList");37

38 int i = 1;39 for(String value : set) {40 System.out.println("第" + i++ + "个抢到商品，"+value + " ");41 }42

43 RedisUtil.returnResource(jedis);44 }45

46 /*

47 * 初始化顾客开始抢商品48 */

49 public static voidinitClient() {50 ExecutorService cachedThreadPool =Executors.newCachedThreadPool();51 int clientNum = 10000;//模拟客户数目

52 for (int i = 0; i < clientNum; i++) {53 cachedThreadPool.execute(newClientThread(i));54 }55 cachedThreadPool.shutdown();56

57 while(true){58 if(cachedThreadPool.isTerminated()){59 System.out.println("所有的线程都结束了！");60 break;61 }62 try{63 Thread.sleep(1000);64 } catch(InterruptedException e) {65 e.printStackTrace();66 }67 }68 }69

70 /**

71 * 初始化商品个数72 */

73 public static voidinitPrduct() {74 int prdNum = 100;//商品个数

75 String key = "prdNum";76 String clientList = "clientList";//抢购到商品的顾客列表

77 Jedis jedis =RedisUtil.getInstance().getJedis();78

79 if(jedis.exists(key)) {80 jedis.del(key);81 }82

83 if(jedis.exists(clientList)) {84 jedis.del(clientList);85 }86

87 jedis.set(key, String.valueOf(prdNum));//初始化

88 RedisUtil.returnResource(jedis);89 }90

91 }92

93 /**

94 * 顾客线程95 *96 *@authorlinbingwen97 *98 */

99 class ClientThread implementsRunnable {100 Jedis jedis = null;101 String key = "prdNum";//商品主键

102 String clientList = "clientList";抢购到商品的顾客列表主键

103 String clientName;104

105 public ClientThread(intnum) {106 clientName = "编号=" +num;107 }108

109 public voidrun() {110 try{111 Thread.sleep((int)(Math.random()*5000));//随机睡眠一下

112 } catch(InterruptedException e1) {113 }114 while (true) {115 System.out.println("顾客:" + clientName + "开始抢商品");116 jedis =RedisUtil.getInstance().getJedis();117 try{118 jedis.watch(key);119 int prdNum = Integer.parseInt(jedis.get(key));//当前商品个数

120 if (prdNum > 0) {121 Transaction transaction =jedis.multi();122 transaction.set(key, String.valueOf(prdNum - 1));123 List result =transaction.exec();124 if (result == null ||result.isEmpty()) {125 System.out.println("悲剧了，顾客:" + clientName + "没有抢到商品");//可能是watch-key被外部修改，或者是数据操作被驳回

126 } else{127 jedis.sadd(clientList, clientName);//抢到商品记录一下

128 System.out.println("好高兴，顾客:" + clientName + "抢到商品");129 break;130 }131 } else{132 System.out.println("悲剧了，库存为0，顾客:" + clientName + "没有抢到商品");133 break;134 }135 } catch(Exception e) {136 e.printStackTrace();137 } finally{138 jedis.unwatch();139 RedisUtil.returnResource(jedis);140 }141

142 }143 }144

View Code

乐观锁

乐观锁不是数据库自带的，需要我们自己去实现。乐观锁是指操作数据库时(更新操作)，想法很乐观，认为这次的操作不会导致冲突，在操作数据时，并不进行任何其他的特殊处理(也就是不加锁)，而在进行更新后，再去判断是否有冲突了。

通常实现是这样的：在表中的数据进行操作时(更新)，先给数据表加一个版本(version)字段，每操作一次，将那条记录的版本号加1。也就是先查询出那条记录，获取出version字段,如果要对那条记录进行操作(更新),则先判断此刻version的值是否与刚刚查询出来时的version的值相等，如果相等，则说明这段期间，没有其他程序对其进行操作，则可以执行更新，将version字段的值加1；如果更新时发现此刻的version值与刚刚获取出来的version的值不相等，则说明这段期间已经有其他程序对其进行操作了，则不进行更新操作。

举例：

下单操作包括3步骤：

1.查询出商品信息

select (status,status,version) from t_goods where id=#{id}

2.根据商品信息生成订单

3.修改商品status为2

update t_goods

set status=2,version=version+1

where id=#{id} and version=#{version};

除了自己手动实现乐观锁之外，现在网上许多框架已经封装好了乐观锁的实现，如hibernate，需要时，可能自行搜索"hiberate 乐观锁"试试看。

悲观锁

与乐观锁相对应的就是悲观锁了。悲观锁就是在操作数据时，认为此操作会出现数据冲突，所以在进行每次操作时都要通过获取锁才能进行对相同数据的操作，这点跟java中的synchronized很相似，所以悲观锁需要耗费较多的时间。另外与乐观锁相对应的，悲观锁是由数据库自己实现了的，要用的时候，我们直接调用数据库的相关语句就可以了。

说到这里，由悲观锁涉及到的另外两个锁概念就出来了，它们就是共享锁与排它锁。共享锁和排它锁是悲观锁的不同的实现，它俩都属于悲观锁的范畴。

共享锁

共享锁指的就是对于多个不同的事务，对同一个资源共享同一个锁。相当于对于同一把门，它拥有多个钥匙一样。就像这样，你家有一个大门，大门的钥匙有好几把，你有一把，你女朋友有一把，你们都可能通过这把钥匙进入你们家，进去啪啪啪啥的，一下理解了哈，没错，这个就是所谓的共享锁。

刚刚说了，对于悲观锁，一般数据库已经实现了，共享锁也属于悲观锁的一种，那么共享锁在mysql中是通过什么命令来调用呢。通过查询资料，了解到通过在执行语句后面加上lock in share mode就代表对某些资源加上共享锁了。

比如，我这里通过mysql打开两个查询编辑器，在其中开启一个事务，并不执行commit语句

city表DDL如下：

CREATE TABLE `city` (

`id` bigint(20) NOT NULL AUTO_INCREMENT,

`name` varchar(255) DEFAULT NULL,

`state` varchar(255) DEFAULT NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;

begin;

SELECT * from city where id = "1"  lock in share mode;

然后在另一个查询窗口中，对id为1的数据进行更新

update  city set name="666" where id ="1";

此时，操作界面进入了卡顿状态，过几秒后，也提示错误信息

[SQL]update  city set name="666" where id ="1";

[Err] 1205 - Lock wait timeout exceeded; try restarting transaction

那么证明，对于id=1的记录加锁成功了，在上一条记录还没有commit之前，这条id=1的记录被锁住了，只有在上一个事务释放掉锁后才能进行操作，或用共享锁才能对此数据进行操作。

再实验一下：

update city set name="666" where id ="1" lock in share mode;

[Err] 1064 - You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'lock in share mode' at line 1

加上共享锁后，也提示错误信息了，通过查询资料才知道，对于update,insert,delete语句会自动加排它锁的原因

于是，我又试了试SELECT * from city where id = "1" lock in share mode;

这下成功了。

排它锁

排它锁与共享锁相对应，就是指对于多个不同的事务，对同一个资源只能有一把锁。

与共享锁类型，在需要执行的语句后面加上for update就可以了

行锁

行锁，由字面意思理解，就是给某一行加上锁，也就是一条记录加上锁。

比如之前演示的共享锁语句

SELECT * from city where id = "1"  lock in share mode;

由于对于city表中,id字段为主键，就也相当于索引。执行加锁时，会将id这个索引为1的记录加上锁，那么这个锁就是行锁。