1.maven引入redisson

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

2.redisson配置類，得到redisson物件，之後的分散式鎖由redisson物件操作

2.1 在springboot的配置檔案application.yml中新增redis叢集的ip和埠還有密碼

spring:
	redis:
		password: 123456
		clusters: 10.10.1.1:7000,10.10.1.1:7001,10.10.1.1:7002,10.10.1.1:7003,10.10.1.1:7004,10.10.1.1:7005

2.2 建立 redisson配置類RedissonManager

import cn.rojao.util.StringUtils;
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.clusters}")
	private  String cluster;
	@Value("${spring.redis.password}")
	private String password;

	@Bean
	public RedissonClient getRedisson(){
		String[] nodes = cluster.split(",");
		//redisson版本是3.5，叢集的ip前面要加上“redis://”，不然會報錯，3.2版本可不加
		for(int i=0;i<nodes.length;i++){
			nodes[i] = "redis://"+nodes[i];
		}
		RedissonClient redisson = null;
		Config config = new Config();
		config.useClusterServers() //這是用的叢集server
				.setScanInterval(2000) //設定叢集狀態掃描時間
				.addNodeAddress(nodes).setRetryAttempts(5).setTimeout(10000);

		if(StringUtils.isNotEmpty(password)){
			config.useClusterServers().setPassword(password);
		}
		redisson = Redisson.create(config);

		//可通過列印redisson.getConfig().toJSON().toString()來檢測是否配置成功
//		try {
//			System.out.println(redisson.getConfig().toJSON().toString());
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
		return redisson;
	}

}
 

3.建立分散式鎖的介面DistributedLocker

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

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);

	void setRedissonClient(RedissonClient redissonClient);
}
 

4.建立介面DistributedLocker的實現類

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 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 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;
        }
    }

    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    @Override
    public void unlock(RLock lock) {
        lock.unlock();
    }

    @Override
    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }
}

5.使用分散式鎖

import cn.rojao.redisson.DistributedLocker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/redission")
public class testController {
	@Autowired
	private DistributedLocker distributedLocker;

	@RequestMapping("/test")
	public void check() {
		try {
			new Thread(() -> {
				try {
					System.out.println("準備獲取鎖1");
					long timestart = System.currentTimeMillis();
					boolean isGetLock = distributedLocker.tryLock("889941", TimeUnit.SECONDS, 2L, 5L);
					long timeend = System.currentTimeMillis();
					System.out.println("獲取鎖1需要的時間:"+String.valueOf(timestart-timeend));
					System.out.println(isGetLock);
					//Thread.sleep(5000);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			).start();

			new Thread(() -> {
						try {
							System.out.println("準備獲取鎖2");
							long timestart = System.currentTimeMillis();
							boolean isGetLock = distributedLocker.tryLock("889941",TimeUnit.SECONDS, 6L, 15L);
							long timeend = System.currentTimeMillis();
							System.out.println("獲取鎖2需要的時間:"+String.valueOf(timestart-timeend));
							System.out.println(isGetLock);

						} catch (Exception e) {
							e.printStackTrace();
						}
					}
			).start();

		} catch (Exception e) {
			e.printStackTrace();
		}
    }

}