为什么要使用分布式锁
1、一个操作要修改用户的状态，修改状态需要先读出用户的状态，在内存里进行修 改，改完了再存回去。如果这样的操作同时进行了，就会出现并发问题，因为读取和保存状 态这两个操作不是原子的。
2、一定在高并发的情况下才会出现线程不安全的情况，在高并发情况，有很多个线程执行这个不是原子的操作，会导致数据的错乱
比如i++这个操作是分为3步进行的，首先在堆内存中分配内存，然后将i的值加1，最后将这个值放写会堆内存
代码示例
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.geekq.miaosha.redis.redismanager.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
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);
}
}
}
}
实现分布式锁的几个注意实现
1、造成死锁的几种情况
- setnx命令和del命令执行的过程中逻辑执行到中间出现异常了，可能会导致 del 指令没有被调用，这样 就会陷入死锁，锁永远得不到释放。
- 在上面的基础上在加上过期命令，但是 setnx 和 expire 之间服务器进程突然挂掉了，可能是因 为机器掉电或者是被人为杀掉的，就会导致 expire 得不到执行，也会造成死锁。
2、出现锁的超时问题
为 set 指令的 value 参数设置为一个随机数，释放锁时先匹配随机数是否一致，然后再删除 key。但是匹配 value 和删除 key 不是一个原子操作，Redis 也没有提供类似于 delifequals 这样的指令，这就需要使用 Lua 脚本来处理了，因为 Lua 脚本可以保证连续多个指令的原子性执行。
RedLock
这个场景是假设有一个 Redis cluster，有 5 个 Redis master 实例。然后执行如下步骤获取一把锁：
尝试在大多数节点上建立一个锁，比如 5 个节点就要求是 3 个节点 n / 2 + 1 ； 客户端计算建立好锁的时间，如果建立锁的时间小于超时时间，就算建立成功了； 要是锁建立失败了，那么就依次之前建立过的锁删除； 只要别人建立了一把分布式锁，你就得不断轮询去尝试获取锁。
