基于redis分布式并发锁的实现理论原理：
https://github.com/huangz1990/redis/commit/18dbaee4f40f435970a09da427b8f45bd26b4072#diff-b643df753e12d0d07a872f91487c957dR34
主要概念：
1、如何争锁
2、锁的表达方式
3、避免死锁
4、死锁过期
网上找了一些资料：针对redisTemplate 实现的，但是在试用过的过程中也遇到了一些坑：
public interface DistributionLock {
//加锁成功 返回加锁时间
Long lock(String lockKey, String threadname);
//解锁 需要更加加锁时间判断是否有权限
void unlock(String lockKey, Long lockvalue, String threadname);
}
public class RedisDistributionLock implements DistributionLock{
private static final long LOCK_TIMEOUT = 10 * 1000; //加锁超时时间 单位毫秒 意味着加锁期间内执行完操作 如果未完成会有并发现象
private static final Logger LOG = LoggerFactory.getLogger(RedisDistributionLock.class); //redis锁日志
@Autowired
@Qualifier("redisTemplateSerializable")
private RedisTemplate redisTemplate;
//如果遇到多个RedisTemplate可以根据名字进行注入
@Resource(name = "redisTemplateString")
private RedisTemplate redisTemplateString;
/**
* 取到锁加锁 取不到锁一直等待直到获得锁
*/
@Override
public synchronized Long lock(final String lockKey, String threadname) {
LOG.info(threadname + "开始执行加锁");
while (true) { //循环获取锁
final Long lock_timeout = System.currentTimeMillis() + LOCK_TIMEOUT + 1; //锁时间
if (redisTemplate.execute(new RedisCallback() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer();
byte[] value = jdkSerializer.serialize(lock_timeout);
return connection.setNX(lockKey.getBytes(), value);
}
})) { //如果加锁成功
LOG.info(threadname + "---加锁成功---lockKey:{},lock_timeout:{}",lockKey,lock_timeout);
redisTemplate.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS); //设置超时时间，释放内存
return lock_timeout;
}else {
Long currt_lock_timeout_Str =
(Long) redisTemplate.opsForValue().get(lockKey); // redis里的时间
if (currt_lock_timeout_Str != null && currt_lock_timeout_Str < System.currentTimeMillis()) { //锁已经失效
// 判断是否为空，不为空的情况下，说明已经失效，如果被其他线程设置了值，则第二个条件判断是无法执行
Long old_lock_timeout_Str = (Long) redisTemplate.opsForValue().getAndSet(lockKey, lock_timeout);
// 获取上一个锁到期时间，并设置现在的锁到期时间
if (old_lock_timeout_Str != null && old_lock_timeout_Str.equals(currt_lock_timeout_Str)) {
// 如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁
LOG.info(threadname + "---加锁成功---lockKey:{},lock_timeout:{}",lockKey,lock_timeout);
redisTemplate.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS); //设置超时时间，释放内存
return lock_timeout;//返回加锁时间
}
}
}
try {
LOG.info(threadname + "等待加锁，睡眠100毫秒");
TimeUnit.MILLISECONDS.sleep(100);//睡眠100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public synchronized void unlock(String lockKey, Long lockvalue, String threadname) {
Long currt_lock_timeout_Str = (Long) redisTemplate.opsForValue().get(lockKey); // redis里的时间
if (currt_lock_timeout_Str != null && currt_lock_timeout_Str .equals( lockvalue)) {//如果是加锁者 则删除锁 如果不是则等待自动过期 重新竞争加锁
redisTemplate.delete(lockKey); //删除键
LOG.info(threadname + "解锁成功:lockKey{},lockValue:{}",lockKey,lockvalue);
}
}
}
关键点：这里的集中序列化方式一定要配置，不然取不到值，调试了很久
@Bean("redisTemplateSerializable")
RedisTemplate redisTemplateSerializable(RedisConnectionFactory connectionFactory) {
RedisTemplate template = new RedisTemplate();
template.setConnectionFactory(connectionFactory);
/**
* 添加属性
*/
StringRedisSerializer stringRedisSerializernew =new StringRedisSerializer();
template.setKeySerializer(stringRedisSerializernew);
template.setHashKeySerializer(stringRedisSerializernew);
JdkSerializationRedisSerializer jdkSerializationRedisSerializer =new JdkSerializationRedisSerializer();
template.setValueSerializer(jdkSerializationRedisSerializer);
template.setHashValueSerializer(jdkSerializationRedisSerializer);
return template;
}
测试代码：要注意的是：最好在外层加同步锁，否则会出现一种奇怪的现象，就是每次都是到锁过期才释放锁，抢先进入任务的线程，会被堵在释放锁的外面：
@RequestMapping(value = {"/redis/dist/test/{lockKey}"},method = RequestMethod.GET)
public void testDistLock(@PathVariable("lockKey") String lockKey1){
AtomicBoolean isFinish = new AtomicBoolean(false);
final ReentrantLock lock = new ReentrantLock();
for(int i=0;i<1;i++){
final String lockKey = lockKey1;
new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lockInterruptibly();
Long lockValue = redisDistributionLock.lock(lockKey,Thread.currentThread().getName());
System.out.println("获得锁："+lockValue);
System.out.println("执行任务......");
// redisDistributionLock.unlock(lockKey,lockValue,Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}).start();
}
}