redisson分布式锁

官网地址

1. Redisson的整合

添加对应的依赖

    	<dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.16.1</version>
        </dependency>

添加对应的配置类

@Configuration
public class RedisConfig {
    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.100.241:6379").setPassword("123456");
        return  Redisson.create(config);
    }
}

2. 可重入锁(Reentrant Lock)

Redisson的分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁。

2.1 同步执行

public void testReentrantLock(RedissonClient redisson){
	RLock lock = redisson.getLock("anyLock");
	try{
		// 1. 最常见的使用方法
		//lock.lock();
		// 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
		//lock.lock(10, TimeUnit.SECONDS);
		// 3. 尝试加锁，最多等待3秒，上锁以后10秒自动解锁
		boolean res = lock.tryLock(3, 10, TimeUnit.SECONDS);
		if(res){ //成功
			//执行业务代码
		}
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		lock.unlock();
	}
}

2.2 异步执行

public void testAsyncReentrantLock(RedissonClient redisson){
	RLock lock = redisson.getLock("anyLock");
	try{
	//	lock.lockAsync();
	//	lock.lockAsync(10, TimeUnit.SECONDS);
		Future<Boolean> res = lock.tryLockAsync(3, 10, TimeUnit.SECONDS);
		if(res.get()){
		//执行业务代码
		}
	} catch (InterruptedException e) {
		e.printStackTrace();
	} catch (ExecutionException e) {
		e.printStackTrace();
	} finally {
		lock.unlock();
	}
}

3. 公平锁（fairlock）

Redisson分布式可重入公平锁也是实现了java.util.concurrent.locks.Lock接口的一种RLock对象。在提供了自动过期解锁功能的同时，保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程。

public void testFairLock(RedissonClient redisson){
	RLock fairLock = redisson.getFairLock("anyLock");
	try{
		// 最常见的使用方法
		fairLock.lock();
		// 支持过期解锁功能, 10秒钟以后自动解锁,无需调用unlock方法手动解锁
		fairLock.lock(10, TimeUnit.SECONDS);
		// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
		boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		fairLock.unlock();
	}
}

4. 联锁（MultiLock）

Redisson的RedissonMultiLock对象可以将多个RLock对象关联为一个联锁，每个RLock对象实例可以来自于不同的Redisson实例。

public void testMultiLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){
	RLock lock1 = redisson1.getLock("lock1");
	RLock lock2 = redisson2.getLock("lock2");
	RLock lock3 = redisson3.getLock("lock3");
	RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
	try {
		// 同时加锁：lock1 lock2 lock3, 所有的锁都上锁成功才算成功。
		lock.lock();
		// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
		boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		lock.unlock();
	}
}

5. 红锁（Redlock）

Redisson的RedissonRedLock对象实现了Redlock介绍的加锁算法。该对象也可以用来将多个RLock对象关联为一个红锁，每个RLock对象实例可以来自于不同的Redisson实例。

public void testRedLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){
	RLock lock1 = redisson1.getLock("lock1");
	RLock lock2 = redisson2.getLock("lock2");
	RLock lock3 = redisson3.getLock("lock3");
	RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
	try {
		// 同时加锁：lock1 lock2 lock3, 红锁在大部分节点上加锁成功就算成功。
		lock.lock();
		// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
		boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		lock.unlock();
	}
}

6. 读写锁（ReadWriteLock）

在读写锁中，只有读读锁是共享锁，不管是先读锁后写锁还是先写锁后读锁，这个都是互斥锁（排他锁），只有等待写锁完成才能进行读锁

    @ResponseBody
    @GetMapping("/write")
    public String writeValue(){
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.writeLock();
        rLock.lock();//加写锁
        String s=null;
        try {
            s= UUID.randomUUID().toString();
            stringRedisTemplate.opsForValue().set("msg", s);
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally{
            rLock.unlock();
        }
        return s;
    }

    /**
     * 在读写锁中，只有读读锁是共享锁，不管是先读锁后写锁还是先写锁后读锁，这个都是互斥锁（排他锁），只有等待写锁完成才能进行读锁
     * @return
     */
    @ResponseBody
    @GetMapping("/read")
    public  String readValue(){
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.readLock();
        //获取读锁
        rLock.lock();
        String s=null;
        try {
            String msg = stringRedisTemplate.opsForValue().get("msg");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally{
            rLock.unlock();
        }
        return  null;
    }

7. 信号量（Semaphore）

设置一个信号量的值，当这个值达到0的时候阻塞掉，只有在释放了信号量的时候，这个就又可以运行

    @ResponseBody
    @GetMapping("/park")
    public  String park(){
//        获取信号量
        RSemaphore  park = redissonClient.getSemaphore("park");
            Boolean b=true;
        try {
//            park.acquire(); //获取信号，阻塞到获取成功
            b = park.tryAcquire();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return "park"+b;
    }
    @ResponseBody
    @GetMapping("/release")
    public  String release(){
        RSemaphore park = redissonClient.getSemaphore("park");
        park.release();
        return "释放锁";
    }

8 闭锁（CountDownLatch）

每请求异常countdown一次，直到设置的值为0

   @ResponseBody
    @GetMapping("/lookDoor")
    public  String lookDoor(){
        RCountDownLatch lockDoor = redissonClient.getCountDownLatch("lockDoor");
        lockDoor.trySetCount(5);
        try {
            lockDoor.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return  "关门熄灯....";
    }
    @ResponseBody
    @GetMapping("/goHome/{id}")
    public  String lookDoor(@PathVariable("id") int id){
        RCountDownLatch lockDoor = redissonClient.getCountDownLatch("lockDoor");
        lockDoor.countDown();
        return id+ "回家了";
    }