public boolean lock(KeyColumn kc, T requester, Instant expires) {
}
引入本地锁机制,主要目的: 在图实例维度来做一层锁判断,减少分布式锁的并发冲突
,减少分布式锁带来的性能消耗
2.4 分布式锁
在本地锁
获取成功之后才会去尝试获取分布式锁
;
分布式锁的获取整体分为两部分流程:
分布式锁信息插入
分布式锁信息状态判断
分布式锁信息插入
该部分主要是通过lockID
来构造要插入的Rowkey和column
并将数据插入到hbase
中;插入成功即表示这部分处理成功!
具体流程如下:
分布式锁信息状态判断
该部分在上一部分完成之后才会进行,主要是判断分布式锁是否获取成功!
查询出当前hbase中对应Rowkey的所有column
,过滤未过期的column集合,比对集合的第一个column是否等于当前事务插入的column;
等于则获取成功!不等于则获取失败!
具体流程如下:
三:源码分析 与 整体流程
源码分析已经push到github:https://github.com/YYDreamer/janusgraph
1、获取锁的入口
public void acquireLock(StaticBuffer key, StaticBuffer column, StaticBuffer expectedValue, StoreTransaction txh) throws BackendException {
// locker是一个一致性key锁对象
if (locker != null) {
// 获取当前事务对象
ExpectedValueCheckingTransaction tx = (ExpectedValueCheckingTransaction) txh;
// 判断:当前的获取锁操作是否当前事务的操作中存在增删改的操作
if (tx.isMutationStarted())
throw new PermanentLockingException(“Attempted to obtain a lock after mutations had been persisted”);
// 使用key+column组装为lockID,供下述加锁使用!!!!!
KeyColumn lockID = new KeyColumn(key, column);
log.debug(“Attempting to acquireLock on {} ev={}”, lockID, expectedValue);
// 获取本地当前jvm进程中的写锁(看下述的 1:写锁获取分析)
// (此处的获取锁只是将对应的KLV存储到Hbase中!存储成功并不代表获取锁成功)
// 1. 获取成功(等同于存储成功)则继续执行
// 2. 获取失败(等同于存储失败),会抛出异常,抛出到最上层,打印错误日志“Could not commit transaction [“+transactionId+”] due to exception” 并抛出对应的异常,本次插入数据结束
locker.writeLock(lockID, tx.getConsistentTx());
// 执行前提:上述获取锁成功!
// 存储期望值,此处为了实现当相同的key + value + tx多个加锁时,只处理第一个
// 存储在事务对象中,标识在commit判断锁是否获取成功时,当前事务插入的是哪个锁信息
tx.storeExpectedValue(this, lockID, expectedValue);
} else {
// locker为空情况下,直接抛出一个运行时异常,终止程序
store.acquireLock(key, column, expectedValue, unwrapTx(txh));
}
}
2、执行 locker.writeLock(lockID, tx.getConsistentTx()) 触发锁获取
public void writeLock(KeyColumn lockID, StoreTransaction tx) throws TemporaryLockingException, PermanentLockingException {
if (null != tx.getConfiguration().getGroupName()) {
MetricManager.INSTANCE.getCounter(tx.getConfiguration().getGroupName(), M_LOCKS, M_WRITE, M_CALLS).inc();
}
// 判断当前事务是否在图实例的维度 已经占据了lockID的锁
// 此处的lockState在一个事务成功获取本地锁+分布式锁后,以事务为key、value为map,其中key为lockID,value为加锁状态(开始时间、过期时间等)
if (lockState.has(tx, lockID)) {
log.debug(“Transaction {} already wrote lock on {}”, tx, lockID);
return;
}
// 当前事务没有占据lockID对应的锁
// 进行(lockLocally(lockID, tx) 本地加锁锁定操作,
if (lockLocally(lockID, tx)) {
boolean ok = false;
try {
// 在本地锁获取成功的前提下:
// 尝试获取基于Hbase实现的分布式锁;
// 注意!!!(此处的获取锁只是将对应的KLV存储到Hbase中!存储成功并不代表获取锁成功)
S stat = writeSingleLock(lockID, tx);
// 获取锁分布式锁成功后(即写入成功后),更新本地锁的过期时间为分布式锁的过期时间
lockLocally(lockID, stat.getExpirationTimestamp(), tx); // update local lock expiration time
// 将上述获取的锁,存储在标识当前存在锁的集合中Map<tx,Map<lockID,S>>, key为事务、value中的map为当前事务获取的锁,key为lockID,value为当前获取分布式锁的ConsistentKeyStatus(一致性密匙状态)对象
lockState.take(tx, lockID, stat);
ok = true;
} catch (TemporaryBackendException tse) {
// 在获取分布式锁失败后,捕获该异常,并抛出该异常
throw new TemporaryLockingException(tse);
} catch (AssertionError ae) {
// Concession to ease testing with mocks & behavior verification
ok = true;
throw ae;
} catch (Throwable t) {
// 出现底层存储错误! 则直接加锁失败!
throw new PermanentLockingException(t);
} finally {
// 判断是否成功获取锁,没有获分布式锁的,则释放本地锁
if (!ok) {
// 没有成功获取锁,则释放本地锁
// lockState.release(tx, lockID); // has no effect
unlockLocally(lockID, tx);
if (null != tx.getConfiguration().getGroupName()) {
MetricManager.INSTANCE.getCounter(tx.getConfiguration().getGroupName(), M_LOCKS, M_WRITE, M_EXCEPTIONS).inc();
}
}
}
} else {
// 如果获取本地锁失败,则直接抛出异常,不进行重新本地争用
// Fail immediately with no retries on local contention
throw new PermanentLockingException(“Local lock contention”);
}
}
包含两个部分:
- 本地锁的获取
lockLocally(lockID, tx)
- 分布式锁的获取
writeSingleLock(lockID, tx)
注意此处只是将锁信息写入到Hbase中,并不代表获取分布式锁成功,只是做了上述介绍的第一个阶段分布式锁信息插入
3、本地锁获取 lockLocally(lockID, tx)
public boolean lock(KeyColumn kc, T requester, Instant expires) {
assert null != kc;
assert null != requester;
final StackTraceElement[] acquiredAt = log.isTraceEnabled() ?
new Throwable("Lock acquisition by " + requester).getStackTrace() : null;
// map的value,以事务为核心
final AuditRecord audit = new AuditRecord<>(requester, expires, acquiredAt);
// ConcurrentHashMap实现locks, 以lockID为key,事务为核心value
final AuditRecord inMap = locks.putIfAbsent(kc, audit);
boolean success = false;
// 代表当前map中不存在lockID,标识着锁没有被占用,成功获取锁
if (null == inMap) {
// Uncontended lock succeeded
if (log.isTraceEnabled()) {
log.trace(“New local lock created: {} namespace={} txn={}”,
kc, name, requester);
}
success = true;
} else if (inMap.equals(audit)) {
// 代表当前存在lockID,比对旧value和新value中的事务对象是否是同一个
// requester has already locked kc; update expiresAt
// 上述判断后,事务对象为同一个,标识当前事务已经获取这个lockID的锁;
// 1. 这一步进行cas替换,作用是为了刷新过期时间
// 2. 并发处理,如果因为锁过期被其他事务占据,则占用锁失败
success = locks.replace(kc, inMap, audit);
if (log.isTraceEnabled()) {
if (success) {
log.trace(“Updated local lock expiration: {} namespace={} txn={} oldexp={} newexp={}”,
kc, name, requester, inMap.expires, audit.expires);
} else {
log.trace(“Failed to update local lock expiration: {} namespace={} txn={} oldexp={} newexp={}”,
kc, name, requester, inMap.expires, audit.expires);
}
}
} else if (0 > inMap.expires.compareTo(times.getTime())) {
// 比较过期时间,如果锁已经过期,则当前事务可以占用该锁
// the recorded lock has expired; replace it
// 1. 当前事务占用锁
// 2. 并发处理,如果因为锁过期被其他事务占据,则占用锁失败
success = locks.replace(kc, inMap, audit);
if (log.isTraceEnabled()) {
log.trace(“Discarding expired lock: {} namespace={} txn={} expired={}”,
kc, name, inMap.holder, inMap.expires);
}
} else {
// 标识:锁被其他事务占用,并且未过期,则占用锁失败
// we lost to a valid lock
if (log.isTraceEnabled()) {
log.trace(“Local lock failed: {} namespace={} txn={} (already owned by {})”,
kc, name, requester, inMap);
log.trace(“Owner stacktrace:\n {}”, Joiner.on("\n ").join(inMap.acquiredAt));
}
}
return success;
}
如上述介绍,本地锁的实现是通过ConcurrentHashMap
数据结构来实现的,在图实例维度下唯一!
4、分布式锁获取第一个阶段:分布式锁信息插入
protected ConsistentKeyLockStatus writeSingleLock(KeyColumn lockID, StoreTransaction txh) throws Throwable {
// 组装插入hbase数据的Rowkey
final StaticBuffer lockKey = serializer.toLockKey(lockID.getKey(), lockID.getColumn());
StaticBuffer oldLockCol = null;
// 进行尝试插入 ,默认尝试次数3次
for (int i = 0; i < lockRetryCount; i++) {
// 尝试将数据插入到hbase中;oldLockCol表示要删除的column代表上一次尝试插入的数据
WriteResult wr = tryWriteLockOnce(lockKey, oldLockCol, txh);
// 如果插入成功
if (wr.isSuccessful() && wr.getDuration().compareTo(lockWait) <= 0) {
final Instant writeInstant = wr.getWriteTimestamp(); // 写入时间
final Instant expireInstant = writeInstant.plus(lockExpire);// 过期时间
return new ConsistentKeyLockStatus(writeInstant, expireInstant); // 返回插入对象
}
// 赋值当前的尝试插入的数据,要在下一次尝试时删除
oldLockCol = wr.getLockCol();
// 判断插入失败原因,临时异常进行尝试,非临时异常停止尝试!
handleMutationFailure(lockID, lockKey, wr, txh);
}
// 处理在尝试了3次之后还是没插入成功的情况,删除最后一次尝试插入的数据
tryDeleteLockOnce(lockKey, oldLockCol, txh);
// TODO log exception or successful too-slow write here
// 抛出异常,标识导入数据失败
throw new TemporaryBackendException(“Lock write retry count exceeded”);
}
上述只是将锁信息插入,插入成功标识该流程结束
5、分布式锁获取第一个阶段:分布式锁锁定是否成功判定
这一步,是在commit
阶段进行的验证
public void commit() throws BackendException {
// 此方法内调用checkSingleLock 检查分布式锁的获取结果
flushInternal();
tx.commit();
}
最终会调用checkSingleLock
方法,判断获取锁的状态!
protected void checkSingleLock(final KeyColumn kc, final ConsistentKeyLockStatus ls,
final StoreTransaction tx) throws BackendException, InterruptedException {
// 检查是否被检查过
if (ls.isChecked())
return;
// Slice the store
KeySliceQuery ksq = new KeySliceQuery(serializer.toLockKey(kc.getKey(), kc.getColumn()), LOCK_COL_START,
LOCK_COL_END);
// 此处从hbase中查询出锁定的行的所有列! 默认查询重试次数3
List claimEntries = getSliceWithRetries(ksq, tx);
// 从每个返回条目的列中提取timestamp和rid,然后过滤出带有过期时间戳的timestamp对象
final Iterable iterable = Iterables.transform(claimEntries,
e -> serializer.fromLockColumn(e.getColumnAs(StaticBuffer.STATIC_FACTORY), times));
final List unexpiredTRs = new ArrayList<>(Iterables.size(iterable));
for (TimestampRid tr : iterable) { // 过滤获取未过期的锁!
final Instant cutoffTime = now.minus(lockExpire);
if (tr.getTimestamp().isBefore(cutoffTime)) {
…
}
// 将还未过期的锁记录存储到一个集合中
学习路线:
这个方向初期比较容易入门一些,掌握一些基本技术,拿起各种现成的工具就可以开黑了。不过,要想从脚本小子变成黑客大神,这个方向越往后,需要学习和掌握的东西就会越来越多以下是网络渗透需要学习的内容:
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
/7a04c5d629f1415a9e35662316578e07.png#pic_center)
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!