package io.renren.utils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* redisson配置
*/
@Configuration
public class RedissonManager {
@Bean
public RedissonClient getRedisson(){
//redisson版本是3.5,集群的ip前面要加上“redis://”,不然会报错,3.2版本可不加
RedissonClient redisson = null;
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
redisson = Redisson.create(config);
//可通过打印redisson.getConfig().toJSON().toString()来检测是否配置成功
return redisson;
}
}
package io.renren.utils;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
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);
}
package io.renren.utils;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
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();
}
}
package io.renren.api.controller;
import io.renren.utils.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("/redisson")
public class AdvMaterialController {
@Autowired
private DistributedLocker distributedLocker;
private int flag = 10;
@RequestMapping("/test")
public void redissonTest() {
String key = "redisson_key";
for (int i = 0; i < 30; i++) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
try {
System.err.println("=============线程开启============"+Thread.currentThread().getName());
/*distributedLocker.lock(key,10L); //直接加锁,获取不到锁则一直等待获取锁
Thread.sleep(100); //获得锁之后可以进行相应的处理
System.err.println("======获得锁后进行相应的操作======"+Thread.currentThread().getName());
distributedLocker.unlock(key); //解锁
System.err.println("============================="+Thread.currentThread().getName());*/
boolean isGetLock = distributedLocker.tryLock(key, TimeUnit.SECONDS,5L,10L); //尝试获取锁,等待5秒,自己获得锁后一直不解锁则10秒后自动解锁
if(isGetLock){
if(flag!=0){
flag= flag - 1;
}
System.err.println("======获得锁后进行相应的操作======"+Thread.currentThread().getName());
distributedLocker.unlock(key);
System.err.println("============================="+Thread.currentThread().getName());
}else{
System.out.println("结束"+flag);
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
t.start();
}
System.out.println(flag);
}
}