RLock fairLock = redisson.getFairLock("anyLock");
// 最常見的使用方法
fairLock.lock();

 @GetMapping("/do/{orderId}")
    public String grab(@PathVariable("orderId") int orderId, int driverId){
        System.out.println("order:"+orderId+",driverId:"+driverId);
        //此處調(diào)用鎖控制層代碼
        grabService.grabOrder(orderId,driverId);
        return "";
    }

@Autowired
	OrderService orderService;
	
	@Override
	public String grabOrder(int orderId, int driverId) {
		String lock = (orderId+"");
		
		synchronized (lock.intern()) {
			try {
				System.out.println("司機(jī):"+driverId+" 執(zhí)行搶單邏輯");
				//此處調(diào)用訂單業(yè)務(wù)代碼
	            boolean b = orderService.grab(orderId, driverId);
	            if(b) {
	            	System.out.println("司機(jī):"+driverId+" 搶單成功");
	            }else {
	            	System.out.println("司機(jī):"+driverId+" 搶單失敗");
	            }
	            
	        } finally {
	        	
	            
	        }
		}
		
		
		return null;
	}

RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");

RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
// 同時(shí)加鎖：lock1 lock2 lock3
// 紅鎖在大部分節(jié)點(diǎn)上加鎖成功就算成功。
lock.lock();
...
lock.unlock();

RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
// 給lock1，lock2，lock3加鎖，如果沒有手動解開的話，10秒鐘后將會自動解開
lock.lock(10, TimeUnit.SECONDS);

// 為加鎖等待100秒時(shí)間，并在加鎖成功10秒鐘后自動解開
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();

@Component
public class RedisConfig {
	@Bean(name = "redissonRed1")
    @Primary
    public RedissonClient redissonRed1(){
        Config config = new Config();
        config.useSingleServer().setAddress("127.0.0.1:6379").setDatabase(0);
        return Redisson.create(config);
    }
    @Bean(name = "redissonRed2")
    public RedissonClient redissonRed2(){
        Config config = new Config();
        config.useSingleServer().setAddress("127.0.0.1:6380").setDatabase(0);
        return Redisson.create(config);
    }
    @Bean(name = "redissonRed3")
    public RedissonClient redissonRed3(){
        Config config = new Config();
        config.useSingleServer().setAddress("127.0.0.1:6381").setDatabase(0);
        return Redisson.create(config);
    }
    @Bean(name = "redissonRed4")
    public RedissonClient redissonRed4(){
        Config config = new Config();
        config.useSingleServer().setAddress("127.0.0.1:6382").setDatabase(0);
        return Redisson.create(config);
    }
    @Bean(name = "redissonRed5")
    public RedissonClient redissonRed5(){
        Config config = new Config();
        config.useSingleServer().setAddress("127.0.0.1:6383").setDatabase(0);
        return Redisson.create(config);
    }
  }

package com.online.taxi.order.service.impl;

import com.online.taxi.order.constant.RedisKeyConstant;
import com.online.taxi.order.service.GrabService;
import com.online.taxi.order.service.OrderService;

import org.redisson.Redisson;
import org.redisson.RedissonRedLock;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;


@Service
public class GrabRedisRedissonRedLockLockServiceImpl implements GrabService {

    // 紅鎖
    @Autowired
    @Qualifier("redissonRed1")
    private RedissonClient redissonRed1;
    @Autowired
    @Qualifier("redissonRed2")
    private RedissonClient redissonRed2;
    @Autowired
    @Qualifier("redissonRed3")
    private RedissonClient redissonRed3;
    @Autowired
    @Qualifier("redissonRed4")
    private RedissonClient redissonRed4;
    @Autowired
    @Qualifier("redissonRed5")
    private RedissonClient redissonRed5;


    @Autowired
	OrderService orderService;

    @Override
    public String grabOrder(int orderId , int driverId){
        System.out.println("紅鎖實(shí)現(xiàn)類");
        //生成key
        String lockKey = ("" + orderId).intern();


        //redisson鎖 單節(jié)點(diǎn)
//        RLock rLock = redissonRed1.getLock(lockKey);

        //紅鎖 redis son
        RLock rLock1 = redissonRed1.getLock(lockKey);
        RLock rLock2 = redissonRed2.getLock(lockKey);
        RLock rLock3 = redissonRed3.getLock(lockKey);
        RLock rLock4 = redissonRed4.getLock(lockKey);
        RLock rLock5 = redissonRed5.getLock(lockKey);
        RedissonRedLock rLock = new RedissonRedLock(rLock1,rLock2,rLock3,rLock4,rLock5);



        try {

             /**紅鎖
		     * waitTimeout 嘗試獲取鎖的最大等待時(shí)間，超過這個(gè)值，則認(rèn)為獲取鎖失敗
		     * leaseTime   鎖的持有時(shí)間,超過這個(gè)時(shí)間鎖會自動失效（值應(yīng)設(shè)置為大于業(yè)務(wù)處理的時(shí)間，確保在鎖有效期內(nèi)業(yè)務(wù)能處理完）
		     */
            boolean b1 = rLock.tryLock((long)waitTimeout, (long)leaseTime, TimeUnit.SECONDS);

            if (b1){
                System.out.println("加鎖成功");
                // 此代碼默認(rèn) 設(shè)置key 超時(shí)時(shí)間30秒，過10秒，再延時(shí)
                System.out.println("司機(jī):"+driverId+" 執(zhí)行搶單邏輯");
               
                boolean b = orderService.grab(orderId, driverId);
                if(b) {
                    System.out.println("司機(jī):"+driverId+" 搶單成功");
                }else {
                    System.out.println("司機(jī):"+driverId+" 搶單失敗");
                }
                System.out.println("加鎖成功");
            }else {
                System.out.println("加鎖失敗");
            }


        } finally {
        	rLock.unlock();
        }
        return null;
    }

}

 <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.18.0</version>
        </dependency>

    @Value("${spring.redis.host}")
    private String url;

    @Value("${spring.redis.port}")
    private Integer port;

    @Value("${spring.redis.password}")
    private String password;

    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
        log.info("Redisson 初始化 {}",String.format("redis://%s:%d",url,port));
        config.useSingleServer().setAddress(String.format("redis://%s:%d",url,port) )
                .setPassword(password);
        // 創(chuàng)建RedissonClient對象
        return Redisson.create(config);
    }

@Autowired
private RedissonClient redissonClient;


 public List<? extends Object> getCachedConfigList(String ode) {
        List<StructureVo> configuration =null;
        String key = getCacheKey(orgCode, STR_CONFIG_LIST);
        List<Object> cacheConfig = redisCache.getCacheList(key);
        if (!CollectionUtils.isEmpty(cacheConfig)) {
            return cacheConfig;
        }
        RLock lock = redissonClient.getLock(getReddisonEbomCacheKey());
        try {
            lock.lock(DEFAULT_EXPIRE_SECOND,TimeUnit.SECONDS);
            List<Object> secondCacheConfig = redisCache.getCacheList(key);
            if (!CollectionUtils.isEmpty(secondCacheConfig)) {
                log.info("second lock reddison 查詢到緩存釋放鎖！");
                reddisnUnlock(getReddisonEbomCacheKey());
                return cacheConfig;
            }
            log.info("reddison枷鎖成功！存放緩存資源！");
            configuration = this.queryAllConfiguration();
            redisCache.setCacheList(key, configuration);
            redisCache.expire(key, DEFAULT_EXPIRE_HOURS, TimeUnit.HOURS);
        } catch (Exception e) {
            log.error("Happen Exception: " + e.getMessage(),e);
        }finally {
            reddisnUnlock(getReddisonEbomCacheKey());
        }
        return configuration;
    }

    private void reddisnUnlock(String key) {
        log.info(" reddison key {}鎖釋放！",key);
        try {
            RLock unlock = redissonClient.getLock(key);
            if (unlock != null && unlock.isHeldByCurrentThread()) {
                unlock.unlock();
            }
        } catch (IllegalMonitorStateException e) {
            log.info("reddison鎖釋放 Exception: " + e.getMessage(),e);
        }
    }

SET resource_name my_random_value NX PX 30000

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end