//获取锁
        //锁的键值需要具有标志性。
        //例如，现在有两个系统需要对key=user_id,value=user_balance进行操作，这时就可以设计这个键的锁为user_id+"_key"
        String user_id="1";
        String key=user_id+"_key";
        //值设置为一个随机数（下面讲原因）
        String random_value=UUID.randomUUID().toString();
        redisTemplate.execute((RedisCallback<Boolean>) (RedisConnection connection)->{
            //只有2.0以上的版本才支持set返回插入结果Boolean
            //此命令的意思是只有key不存在，才插入值，并且设置有效时间为10s
            connection.set(key.getBytes(), random_value.getBytes(), Expiration.seconds(10), SetOption.SET_IF_ABSENT);
            //本示例由于依赖版本低于2.0,所以无法接受set设置结果
            Boolean result=true;
            return result;
        });
        
        //进行更新操作...
        
        //释放锁
        //为什么释放之前要比较一下？
        //这是为了防止删除掉别人的锁，例如此场景中：如果我们的中间操作超过了10s那么锁会自动释放，这时别人会再获取锁。
        //如果我们执行完中间就直接删除锁的话，就会把别人的锁删除
        if(redisTemplate.opsForValue().get(key)==random_value) {
            redisTemplate.delete(key);
        }

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

singleServerConfig:
  #连接空闲超时，单位：毫秒
  idleConnectionTimeout: 10000
  pingTimeout: 1000
  #连接超时，单位：毫秒
  connectTimeout: 10000
  #命令等待超时，单位：毫秒
  timeout: 3000
  #命令失败重试次数
  retryAttempts: 3
  #命令重试发送时间间隔，单位：毫秒
  retryInterval: 1500
  #重新连接时间间隔，单位：毫秒
  reconnectionTimeout: 3000
  #执行失败最大次数
  failedAttempts: 3
  #单个连接最大订阅数量
  subscriptionsPerConnection: 5
  #客户端名称
  clientName: null
  #地址
  address: "redis://192.168.1.16:6379"
  #数据库编号
  database: 0
  #密码
  password: xiaokong
  #发布和订阅连接的最小空闲连接数
  subscriptionConnectionMinimumIdleSize: 1 
  #发布和订阅连接池大小
  subscriptionConnectionPoolSize: 50
  #最小空闲连接数
  connectionMinimumIdleSize: 32
  #连接池大小
  connectionPoolSize: 64
  #是否启用DNS监测
  dnsMonitoring: false
  #DNS监测时间间隔，单位：毫秒
  dnsMonitoringInterval: 5000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}
transportMode : "NIO"

import org.mybatis.spring.annotation.MapperScan;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement
@MapperScan("com.xxx.mapper")
public class Application {
    public static void main(String [] args) {
        SpringApplication.run(Application.class, args);
    }
    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson() throws IOException {
        RedissonClient redisson = Redisson.create(
                Config.fromYAML(new ClassPathResource("redisson.yml").getInputStream()));
        return redisson;
    }
}

@Autowired
    private RedissonClient redisson;
    @Test 
    public void redisson() {
        String user_id="1";
        String key=user_id+"_key";
        //获取锁
        RLock lock = redisson.getLock(key);
        lock.lock();
            //执行具体逻辑...
        
        RBucket<Object> bucket = redisson.getBucket("a");
        bucket.set("bb");
        
        lock.unlock();
    }

RBucket<Object> bucket = redisson.getBucket("a");
bucket.set("bb");