程序在单台应用的时候，程序上完全可以用synchronized同步锁来限制多线程对共享资源的访问，但在分布式环境下同步锁无法控制不同进程之间的线程，这种情况下就需要找一种单进程可串行处理的“锁”，
所以产生了分布式锁这个玩意；
至于 分布式锁我了解到的实现有三种方案
期初在做这个的时候也考虑了他们的实现优缺点
zookeeper分布式锁
优点：
锁安全性高，zk可持久化。当然 redis 也可以实现持久化。
缺点：
性能开销比较高。因为其需要动态产生、销毁瞬时节点来实现锁功能。
memcached分布式锁
优点：
并发高效。
缺点：
（1）memcached采用列入LRU置换策略，所以如果内存不够，可能导致缓存中的锁信息丢失。
（2）memcached无法持久化，一旦重启，将导致信息丢失。
redis 分布式锁
也是我最推荐的
redis分布式锁即可以结合zk分布式锁锁高度安全和memcached并发场景下效率很好的优点，可以利用jedis客户端实现。代码见最后。
怎么使用
RedisLock redisLockN = redisLock.newInstance(RedisKey.KEY_SETUP_ACCOUNT.getCode(), 10000);
if (redisLockN.lock()) {
//业务代码
redisLockN.unlock();
LOGGER.info(" 释放redis分布式锁");
} else {
LOGGER.error("获取redis分布式锁失败 请检查");
throw new 抛出异常
}
具体实现
把我们的核心代码都复制出来,不知道老大会不会出来打我
@Component
public class RedisLock {
private static final Logger LOGGER = LoggerFactory.getLogger(RedisLock.class);
private static final int DEFAULT_LOCK_EXPIRSE_MILL_SECONDS = 1000*30;
private static final int DEFAULT_LOCK_WAIT_DEFAULT_TIME_OUT = 1000*10;
private static final int DEFAULT_LOOP_WAIT_TIME = 150;
private boolean lock = false;
private String lockKey = null;
private int lockExpriseTimeout;
private int lockWaitTimeOut;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Deprecated
public RedisLock(){}
public RedisLock(String lockKey,int lockExpriseTimeout,int lockWaitTimeOut)
{
this.lockKey = lockKey;
this.lockExpriseTimeout = lockExpriseTimeout;
this.lockWaitTimeOut = lockWaitTimeOut;
}
public RedisLock newInstance(String lockKey,int lockWaitTimeOut)
{
if(lockWaitTimeOut == 0)
{
lockWaitTimeOut = DEFAULT_LOCK_WAIT_DEFAULT_TIME_OUT;
}
RedisLock lock = new RedisLock(lockKey,DEFAULT_LOCK_EXPIRSE_MILL_SECONDS,lockWaitTimeOut);
lock.setStringRedisTemplate(this.stringRedisTemplate);
return lock;
}
private boolean putIfAbsent(String expirseTimeStr)
{
return this.stringRedisTemplate.opsForValue().setIfAbsent(this.lockKey,expirseTimeStr);
}
private String getAndSet(String expirseTimeStr)
{
return this.stringRedisTemplate.opsForValue().getAndSet(this.lockKey,expirseTimeStr);
}
public boolean lock()
{
int lockWaitMillSeconds = this.lockWaitTimeOut;
String redis_value = String.valueOf(System.currentTimeMillis()+this.lockExpriseTimeout);
while(lockWaitMillSeconds > 0)
{
lock = this.putIfAbsent(redis_value);
if(lock)
{
this.lock = true;
return this.lock;
}
else
{
String oldRedisValue = this.stringRedisTemplate.opsForValue().get(this.lockKey);
long currentTimeMillSeconds = System.currentTimeMillis();
if(!StringUtils.isEmpty(oldRedisValue) && Long.parseLong(oldRedisValue) < currentTimeMillSeconds)
{
String currentRedisValue = this.getAndSet(String.valueOf(currentTimeMillSeconds+this.lockExpriseTimeout));
if(oldRedisValue.equals(currentRedisValue))
{
this.lock = true;
return this.lock;
}
}
}
lockWaitMillSeconds -= DEFAULT_LOOP_WAIT_TIME;
try
{
Thread.sleep(DEFAULT_LOOP_WAIT_TIME);
}
catch (Exception ex)
{
LOGGER.error("redis同步锁 出现未知异常",ex);
}
}
return false;
}
public void unlock()
{
if (this.lock) {
this.stringRedisTemplate.delete(this.lockKey);
this.lock = false;
}
}
public boolean isLock() {
return lock;
}
public void setLock(boolean lock) {
this.lock = lock;
}
public String getLockKey() {
return lockKey;
}
public void setLockKey(String lockKey) {
this.lockKey = lockKey;
}
public int getLockExpriseTimeout() {
return lockExpriseTimeout;
}
public void setLockExpriseTimeout(int lockExpriseTimeout) {
this.lockExpriseTimeout = lockExpriseTimeout;
}
public int getLockWaitTimeOut() {
return lockWaitTimeOut;
}
public void setLockWaitTimeOut(int lockWaitTimeOut) {
this.lockWaitTimeOut = lockWaitTimeOut;
}
public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
}
