mongo分布式锁Java实现方法(推荐)
一、分布式锁使用场景:
代码部署在多台服务器上,即分布式部署。
多个进程同步访问一个共享资源。
二、需要的技术:
数据库:mongo
java:mongo操作插件类 mongotemplate(maven引用),如下:
<!--mongodo开始--> <dependency> <groupid>org.springframework.data</groupid> <artifactid>spring-data-mongodb</artifactid> <version>1.8.2.release</version> </dependency> <dependency> <groupid>org.springframework.data</groupid> <artifactid>spring-data-commons</artifactid> <version>1.10.0.release</version> </dependency> <dependency> <groupid>org.mongodb</groupid> <artifactid>mongo-java-driver</artifactid> <version>2.13.0-rc2</version> </dependency> <!--mongodo结束-->
三、实现代码:
主实现逻辑及外部调用方法,获得锁调用getlock,释放锁调用releaselock,详情如下:
import java.util.hashmap; import java.util.list; import java.util.map; public class mongodistributedlock { static mongolockdao mongolockdao; static { mongolockdao = springbeanutils.getbean("mongolockdao"); } /** * 获得锁的步骤: * 1、首先判断锁是否被其他请求获得;如果没被其他请求获得则往下进行; * 2、判断锁资源是否过期,如果过期则释放锁资源; * 3.1、尝试获得锁资源,如果value=1,那么获得锁资源正常;(在当前请求已经获得锁的前提下,还可能有其他请求尝试去获得锁,此时会导致当前锁的过期时间被延长,由于延长时间在毫秒级,可以忽略。) * 3.2、value>1,则表示当前请求在尝试获取锁资源过程中,其他请求已经获取了锁资源,即当前请求没有获得锁; * !!!注意,不需要锁资源时,及时释放锁资源!!!。 * * @param key * @param expire * @return */ public static boolean getlock(string key, long expire) { list<mongolock> mongolocks = mongolockdao.getbykey(key); //判断该锁是否被获得,锁已经被其他请求获得,直接返回 if (mongolocks.size() > 0 && mongolocks.get(0).getexpire() >= system.currenttimemillis()) { return false; } //释放过期的锁 if (mongolocks.size() > 0 && mongolocks.get(0).getexpire() < system.currenttimemillis()) { releaselockexpire(key, system.currenttimemillis()); } //!!(在高并发前提下)在当前请求已经获得锁的前提下,还可能有其他请求尝试去获得锁,此时会导致当前锁的过期时间被延长,由于延长时间在毫秒级,可以忽略。 map<string, object> mapresult = mongolockdao.incrbywithexpire(key, 1, system.currenttimemillis() + expire); //如果结果是1,代表当前请求获得锁 if ((integer) mapresult.get("value") == 1) { return true; //如果结果>1,表示当前请求在获取锁的过程中,锁已被其他请求获得。 } else if ((integer) mapresult.get("value") > 1) { return false; } return false; } /** * 释放锁 * * @param key */ public static void releaselock(string key) { map<string, object> condition = new hashmap<>(); condition.put("key", key); mongolockdao.remove(condition); } /** * 释放过期锁 * * @param key * @param expiretime */ private static void releaselockexpire(string key, long expiretime) { mongolockdao.removeexpire(key, expiretime); } }
mongolockdao实现代码:
import org.springframework.data.mongodb.core.findandmodifyoptions; import org.springframework.data.mongodb.core.query.criteria; import org.springframework.data.mongodb.core.query.query; import org.springframework.data.mongodb.core.query.update; import org.springframework.stereotype.repository; import java.util.hashmap; import java.util.list; import java.util.map; @repository public class mongolockdao <mongolock> { private class<?> clz; public class<?> getclz() { if (clz == null) { //获取泛型的class对象 clz = ((class<?>) (((parameterizedtype) (this.getclass().getgenericsuperclass())).getactualtypearguments()[0])); } return clz; } /** * 返回指定key的数据 * * @param key * @return */ public list<mongolock> getbykey(string key) { query query = new query(); query.addcriteria(criteria.where("key").is(key)); return (list<mongolock>) mongotemplate.find(query, getclz()); } /** * 指定key自增increment(原子加),并设置过期时间 * * @param key * @param increment * @param expire * @return */ public map<string, object> incrbywithexpire(string key, double increment, long expire) { //筛选 query query = new query(); query.addcriteria(new criteria("key").is(key)); //更新 update update = new update(); update.inc("value", increment); update.set("expire", expire); //可选项 findandmodifyoptions options = findandmodifyoptions.options(); //没有则新增 options.upsert(true); //返回更新后的值 options.returnnew(true); map<string, object> resultmap = new hashmap<>(); resultmap.put("value", double.valueof(((mongolock) mongotemplate.findandmodify(query, update, options, getclz())).getvalue()).intvalue()); resultmap.put("expire", long.valueof(((mongolock) mongotemplate.findandmodify(query, update, options, getclz())).getexpire()).longvalue()); return resultmap; } /** * 根据value删除过期的内容 * * @param key * @param expiretime */ public void removeexpire(string key, long expiretime) { query query = new query(); query.addcriteria(criteria.where("key").is(key)); query.addcriteria(criteria.where("expire").lt(expiretime)); mongotemplate.remove(query, getclz()); } public void remove(map<string, object> condition) { query query = new query(); set<map.entry<string, object>> set = condition.entryset(); int flag = 0; for (map.entry<string, object> entry : set) { query.addcriteria(criteria.where(entry.getkey()).is(entry.getvalue())); flag = flag + 1; } if (flag == 0) { query = null; } mongotemplate.remove(query, getclz()); } }
mongolock实体:
public class mongolock { private string key; private double value; private long expire; public double getvalue() { return value; } public void setvalue(double value) { this.value = value; } public long getexpire() { return expire; } public void setexpire(long expire) { this.expire = expire; } public string getkey() { return key; } public void setkey(string key) { this.key = key; } }
四、设计思路
前提:利用mongo实现id自增,且自增过程为原子操作,即线程安全。
假设有a、b两个请求通过请求资源。
当a请求到资源是调用mongo自增 +1,并将结果返回给a,即1,此时结果等于1则表明,a请求过程中没有其他请求请求到资源,将锁资源分配给a。
当b请求到资源是调用mongo自增 +1,并将结果返回给a,即2。此时结果大于1则表明,b请求过程中有其他请求请求到资源,锁资源不能分配给b。
这样就是实现了多个请求请求同一个锁并且排队。
关于锁过期时间 :
如果图中代码1releaselockexpire(key, system.currenttimemillis())修改为releaselockexpire(key),即在释放锁的时候没有传入过期时间,会产生如下情况:
a、b两个请求同时通过条件,进入到代码 1
b执行完删除操作,进入代码2,并且刚刚获得到锁资源,而此时a及有可能刚开始执行释放锁的操作。
此时就会发生,a释放了b刚刚获得的锁,这样b就会失去刚刚获得的锁,而b确没有感知,从而造成逻辑错误。
而releaselockexpire(key, system.currenttimemillis()),即在释放锁的时候判断一下过期时间,这样就不会误删b刚刚获得的锁。
以上这篇mongo分布式锁java实现方法(推荐)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持。