谷粒商城 高级篇 (十) --------- 分布式锁

---

一、分布式锁

1. 基本原理

2. 使用 RedisTemplate 操作分布式锁

代码演进：

使用 RedisTemplate 操作分布式锁
public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock() {
	//1、占分布式锁。去 redis 占坑
	String uuid = UUID.randomUUID().toString();
	Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,TimeUnit.SECONDS);
	if(lock){
		System.out.println("获取分布式锁成功...");
		//加锁成功... 执行业务
		//2、设置过期时间，必须和加锁是同步的，原子的
		//redisTemplate.expire("lock",30,TimeUnit.SECONDS);
		Map<String, List<Catelog2Vo>> dataFromDb;
		try{
			dataFromDb = getDataFromDb();
		} finally {
			String script = "if redis.call('get', KEYS[1]) == ARGV[1] thenreturn redis.call('del', KEYS[1]) else return 0 end";
			//删除锁
			Long lock1 = redisTemplate.execute(new	DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);
		}
		//获取值对比+对比成功删除=原子操作 lua 脚本解锁
		// String lockValue = redisTemplate.opsForValue().get("lock");
		// if(uuid.equals(lockValue)){
		// //删除我自己的锁
		// redisTemplate.delete("lock");//删除锁
	    //}
		return dataFromDb;
	} else {
		//加锁失败...重试。synchronized ()
		//休眠 100ms 重试
		System.out.println("获取分布式锁失败...等待重试");
		try{
			Thread.sleep(200);
		} catch (Exception e){
		
		}
		return getCatalogJsonFromDbWithRedisLock();//自旋的方式
	}
}

使用 RedisTemplate 操作分布式的关键是：加锁与删锁操作的原子性

二、Redisson 完成分布式锁

1、简介

Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格（In-Memory Data Grid）。充分的利用了 Redis 键值数据库提供的一系列优势，基于 Java 实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。

官方文档：https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95

2、配置

// 默认连接地址 127.0.0.1:6379
RedissonClient redisson = Redisson.create();
Config config = new Config();
//redis://127.0.0.1:7181
//可以用"rediss://"来启用 SSL 连接
config.useSingleServer().setAddress("redis://192.168.56.10:6379");
RedissonClient redisson = Redisson.create(config);

3、测试

① 可重入锁 (Reentrant Lock)

@ResponseBody
@GetMapping(value = "/hello")
public String hello() {

	//1、获取一把锁，只要锁的名字一样，就是同一把锁
	RLock myLock = redisson.getLock("my-lock");
	
	//2、加锁
	myLock.lock();      //阻塞式等待。默认加的锁都是30s
	//1）、锁的自动续期，如果业务超长，运行期间自动锁上新的30s。不用担心业务时间长，锁自动过期被删掉
	//2）、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s内自动过期，不会产生死锁问题
	// myLock.lock(10,TimeUnit.SECONDS);   //10秒钟自动解锁,自动解锁时间一定要大于业务执行时间
	//问题：在锁时间到了以后，不会自动续期
	//1、如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是 我们制定的时间
	//2、如果我们指定锁的超时时间，就使用 lockWatchdogTimeout = 30 * 1000 【看门狗默认时间】
	//只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10秒都会自动的再次续期，续成30秒
	// internalLockLeaseTime 【看门狗时间】 / 3， 10s
	try {
		System.out.println("加锁成功，执行业务..." + Thread.currentThread().getId());
	try { 
		TimeUnit.SECONDS.sleep(20); 
	} catch (InterruptedException e) { 
		e.printStackTrace();     	}
	} catch (Exception ex) {
		ex.printStackTrace();
	} finally {
		//3、解锁  假设解锁代码没有运行，Redisson会不会出现死锁
		System.out.println("释放锁..." + Thread.currentThread().getId());
		myLock.unlock();
	}

	return "hello";
}

② 读写锁 (ReadWriteLock)

/**
 * 保证一定能读到最新数据，修改期间，写锁是一个排它锁（互斥锁、独享锁），读锁是一个共享锁
 * 写锁没释放读锁必须等待
 * 读 + 读 ：相当于无锁，并发读，只会在Redis中记录好，所有当前的读锁。他们都会同时加锁成功
 * 写 + 读 ：必须等待写锁释放
 * 写 + 写 ：阻塞方式
 * 读 + 写 ：有读锁。写也需要等待
 * 只要有读或者写的存都必须等待
 * @return
 */
@GetMapping(value = "/write")
@ResponseBody
public String writeValue() {
    String s = "";
    RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
    RLock rLock = readWriteLock.writeLock();
    try {
        //1、改数据加写锁，读数据加读锁
        rLock.lock();
        s = UUID.randomUUID().toString();
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        ops.set("writeValue",s);
        TimeUnit.SECONDS.sleep(10);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
    }

    return s;
}


@GetMapping(value = "/read")
@ResponseBody
public String readValue() {
    String s = "";
    RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
    //加读锁
    RLock rLock = readWriteLock.readLock();
    try {
        rLock.lock();
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        s = ops.get("writeValue");
        try { TimeUnit.SECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
    }

    return s;
}

③ 信号量 (Semaphore)

/**
* 车库停车
* 3车位
* 信号量也可以做分布式限流
*/
@GetMapping(value = "/park")
@ResponseBody
public String park() throws InterruptedException {

    RSemaphore park = redisson.getSemaphore("park");
    park.acquire();     //获取一个信号、获取一个值,占一个车位
    boolean flag = park.tryAcquire();

    if (flag) {
        //执行业务
    } else {
        return "error";
    }

    return "ok=>" + flag;
}

@GetMapping(value = "/go")
@ResponseBody
public String go() {
    RSemaphore park = redisson.getSemaphore("park");
    park.release();     //释放一个车位
    return "ok";
}

④ 闭锁 (CountDownLatch)

 /**
  * 放假、锁门
  * 1班没人了
  * 5个班，全部走完，我们才可以锁大门
  * 分布式闭锁
  */

 @GetMapping(value = "/lockDoor")
 @ResponseBody
 public String lockDoor() throws InterruptedException {

     RCountDownLatch door = redisson.getCountDownLatch("door");
     door.trySetCount(5);
     door.await();       //等待闭锁完成

     return "放假了...";
 }

 @GetMapping(value = "/gogogo/{id}")
 @ResponseBody
 public String gogogo(@PathVariable("id") Long id) {
     RCountDownLatch door = redisson.getCountDownLatch("door");
     door.countDown();       //计数-1

     return id + "班的人都走了...";
 }

三、缓存数据一致性

数据库中的数据与缓存中的数据如何保持一致?

1. 保证一致性模式

双写模式：数据更新时同时更改数据库与缓存

失效模式：数据更新时写数据库同时删缓存

2. 解决方案

无论是双写模式还是失效模式，都会导致缓存的不一致问题。即多个实例同时更新会出事。怎么办？

1、如果是用户纬度数据 (订单数据、用户数据)，这种并发几率非常小，不用考虑这个问题，缓存数据加上过期时间，每隔一段时间触发读的主动更新即可。

2、如果是菜单，商品介绍等基础数据，也可以去使用 canal 订阅 binlog 的方式。

3、缓存数据+过期时间也足够解决大部分业务对于缓存的要求。

4、通过加锁保证并发读写，写写的时候按顺序排好队。读读无所谓。所以适合使用读写锁。（业务不关心脏数据，允许临时脏数据可忽略）；

总结：

1、我们能放入缓存的数据本就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间，保证每天拿到当前最新数据即可。

2、我们不应该过度设计，增加系统的复杂性

3、遇到实时性、一致性要求高的数据，就应该查数据库，即使慢点。

Canal 模式：

/**
* 缓存里的数据如何和数据库的数据保持一致？？
* 缓存数据一致性
* 1)、双写模式
* 2)、失效模式
* @return
*/
public Map<String, List<Catelog2Vo>> getCatelogJsonFormDBWithRedissionLock() {
	//1. 占分布式锁, 去 redis 占坑
	//(锁的粒度，越细越快:具体缓存的是某个数据，11号商品) product-11-lock
	//RLock catalogJsonLock = redissonClient.getLock("catalogJson-lock");
    //创建读锁
    RReadWriteLock readWriteLock = redissionClient.getReadWriteLock("catelogJson-lock");
    RLock rLock = readWriteLock.readLock();
 	Map<String, List<Catelog2Vo>> dataFromDb = null;
 	try {
 		rLock.lock();
 		dataFromDb = getDataFromDb();	
 	} finally {
 		rLock.unlock();
 	}
	//先去redis查询下保证当前的锁是自己的
    //获取值对比，对比成功删除=原子性 lua脚本解锁
    // String lockValue = stringRedisTemplate.opsForValue().get("lock");
    // if (uuid.equals(lockValue)) {
    //     //删除我自己的锁
    //     stringRedisTemplate.delete("lock");
    // }
    return dataFromDb;
}