springboot高并发redis细粒度加锁(key粒度加锁)

reko_3

　　本文探讨在web开发中如何解决并发访问带来的数据同步问题。
　　1、需求：
　　通过REST接口请求并发访问redis，例如:将key=fusor:${order_id} 中的值+1；
　　2、场景：
　　设想，多线程对key=fusor:${order_id}并发访问触发了竞态条件，例如两个线程同时发现key=fusor:${order_id}的值为5，然后并且+1回写6，这个时候就出现了问题，最终的值为6而不是7。
　　3、粗粒度锁：
　　这时候，普遍的做法是加锁，但是如果对整个访问redis的动作加锁，那么等于多个线程串行访问了！
　　4、细粒度加锁：
　　我们这里的做法是对key进行细粒度加锁，每个key拥有一把锁，只对key进行并发控制，key与key之间允许并发。
　　直接上代码
　　

package com.xiaoju.dqa.fusor.utils;　　

　　

　　

import org.slf4j.Logger;　　

import org.slf4j.LoggerFactory;　　

import org.springframework.beans.factory.annotation.Autowired;　　

import org.springframework.stereotype.Component;　　

　　

import java.util.Random;　　

import java.util.UUID;　　

　　

　　
@Component
　　

public>private static Logger logger = LoggerFactory.getLogger(SexyLockUtil.class);　　

　　@Autowired
private SexyLocker<K> sexyLocker;　　

public KeyLocker<K> getKeyLocker(K key) {return new KeyLocker<K>(sexyLocker, key);　　}
　　

public static>private UUID uuid = UUID.randomUUID();private SexyLocker sexyLocker;private K key;　　

public KeyLocker(SexyLocker sexyLocker, K key) {this.sexyLocker = sexyLocker;this.key = key;　　}
　　

　　

public boolean lockWithRetry(int expireTime, int retryTimes) {　　Random random
= new Random();for (int i = 0; i < retryTimes; i++) {if (this.lock()) {return true;　　}
else {try {　　Thread.sleep(random.nextInt(
50));　　}
catch (InterruptedException e) {　　

　　}
　　}
　　}
return false;　　}
　　

public boolean lock() {try {this.sexyLocker.lock(key);return true;　　}
catch (Exception e) {return false;　　}
　　

　　}
　　

public boolean unlock() {try {this.sexyLocker.unlock(key);return true;　　}
catch (Exception e) {return false;　　}
　　}
　　}
　　
}
　　

　　

package com.xiaoju.dqa.fusor.utils;　　

　　

　　

import org.slf4j.Logger;　　

import org.slf4j.LoggerFactory;　　

import org.springframework.stereotype.Component;　　

　　

import java.util.HashMap;　　

import java.util.Map;　　

import java.util.concurrent.ConcurrentHashMap;　　

import java.util.concurrent.ConcurrentMap;　　

import java.util.concurrent.Semaphore;　　

　　
@Component
　　

public>private static Logger logger = LoggerFactory.getLogger(SexyLockUtil.class);　　

private final ConcurrentMap<K, Semaphore> map = new ConcurrentHashMap<K, Semaphore>();private final ThreadLocal<Map<K, LockInfo>> local = new ThreadLocal<Map<K, LockInfo>>() {　　@Override
protected Map<K, LockInfo> initialValue() {return new HashMap<K, LockInfo>();　　}
　　};
　　

public void lock(K key) {if (key == null)return;　　LockInfo info
= local.get().get(key);if (info == null) {　　Semaphore current
= new Semaphore(1);　　current.acquireUninterruptibly();
　　Semaphore previous
= map.put(key, current);if (previous != null)　　previous.acquireUninterruptibly();
　　local.get().put(key,
new LockInfo(current));　　}
else {　　info.lockCount
++;　　}
　　}
　　

public void unlock(K key) {if (key == null)return;　　LockInfo info
= local.get().get(key);if (info != null && --info.lockCount == 0) {　　info.current.release();
　　map.remove(key, info.current);
　　local.get().remove(key);
　　}
　　}
　　

public void lock(K[] keys) {if (keys == null)return;for (K key : keys) {　　lock(key);
　　}
　　}
　　

public void unlock(K[] keys) {if (keys == null)return;for (K key : keys) {　　unlock(key);
　　}
　　}
　　

private static>private final Semaphore current;private int lockCount;　　

private LockInfo(Semaphore current) {this.current = current;this.lockCount = 1;　　}
　　}
　　
}