redisson官网推荐分布式锁

简单的使用方法【注意：不支持高并发和高吞吐量，需要更具场景优化】

1.引入包

  		 <!-- 分布式锁 整合spring-->
		<dependency>
			<groupId>org.redisson</groupId>
			<artifactId>redisson</artifactId>
			<version>3.5.0</version>
		</dependency>

2.下面通过简单的案例使用redisson的lock。

2.1、redisson配置类，连接redis用。

package com.companyparent.msm.common.lockredisson;

/**
 * @Author: lijunwei
 * @Time: 2018/12/9 13:02
 */

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * redisson配置
 */
@Configuration
public class RedissonManager {
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private String port;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.database}")
    private int database;

    @Bean
    public RedissonClient getRedisson(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password).setDatabase(database);
        return Redisson.create(config);
    }
}

2.2、SpringBoot配置文件。

spring:　　
  redis:
    host: 192.168.1.50
    database: 9
    port: 6379
    password: bizvane
    jedis:
      pool:
        max-active: 100
        max-idle: 8
        max-wait: 2000ms
        min-idle: 0

2.3、RLock接口类

package com.companyparent.msm.common.lockredisson;

import org.redisson.api.RLock;

import java.util.concurrent.TimeUnit;

public interface DistributedLocker {
    RLock lock(String lockKey);

    RLock lock(String lockKey, long timeout);

    RLock lock(String lockKey, TimeUnit unit, long timeout);

    boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime);

    void unlock(String lockKey);

    void unlock(RLock lock);

}

4、RedissonDistributedLocker 实现类。

package com.companyparent.msm.common.lockredisson;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 */
@Component
public class RedissonDistributedLocker implements DistributedLocker {
    @Autowired
    private RedissonClient redissonClient;  //RedissonClient已经由配置类生成，这里自动装配即可

    //lock(), 拿不到lock就不罢休，不然线程就一直block
    @Override
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    //leaseTime为加锁时间，单位为秒
    @Override
    public RLock lock(String lockKey, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
        return lock;
    }

    //timeout为加锁时间，时间单位由unit确定
    @Override
    public synchronized RLock lock(String lockKey, TimeUnit unit , long timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }
    //tryLock()，马上返回，拿到lock就返回true，不然返回false。
    //带时间限制的tryLock()，拿不到lock，就等一段时间，超时返回false.
    @Override
    public synchronized boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 根据释放锁
     * @param lockKey
     */
    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    /**
     * 释放锁
     * @param lock
     */
    @Override
    public void unlock(RLock lock) {
        lock.unlock();
    }
}

3.测试test

package com.companyparent.msm.test;

import java.util.concurrent.TimeUnit;

import org.redisson.api.RLock;
import org.redisson.client.RedisClient;

import com.companyparent.msm.common.lockredisson.DistributedLocker;
import com.companyparent.msm.common.utils.SpringContextUtil;


public class redisLock {
	static DistributedLocker distributedLocker = SpringContextUtil.getBean(DistributedLocker.class);
	private static void redisLock(){
        for (int i = 0; i < 100; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        String key = "test123";
                        DistributedLocker distributedLocker = SpringContextUtil.getBean(DistributedLocker.class);
                        //获取锁
                        RLock lock = distributedLocker.lock("templateMessageKey_" + key, TimeUnit.SECONDS, 30L);
                        System.err.println("======获得锁后进行相应的操作======");
                        //TODO 操作业务
                        System.err.println("======操作完释放锁===============");
                        //释放锁
                        distributedLocker.unlock(lock);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }

}