final _PendingTxn transferExclusive(_LockOwner locker, _Lock lock, _PendingTxn pending) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { return lock.transferExclusive(locker, ht, pending); } finally { ht.releaseExclusive(); } }
final void unlockToUpgradable(_LockOwner locker, _Lock lock) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { lock.unlockToUpgradable(locker, ht); } catch (Throwable e) { ht.releaseExclusive(); throw e; } }
final void unlockToShared(_LockOwner locker, _Lock lock) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { lock.unlockToShared(locker, ht); } finally { ht.releaseExclusive(); } }
final void unlockToUpgradable(_LockOwner locker, _Lock lock) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { lock.unlockToUpgradable(locker, ht); } finally { ht.releaseExclusive(); } }
final void unlock(_LockOwner locker, _Lock lock) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { lock.unlock(locker, ht); } catch (Throwable e) { ht.releaseExclusive(); throw e; } }
final _PendingTxn transferExclusive(_LockOwner locker, _Lock lock, _PendingTxn pending) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { return lock.transferExclusive(locker, ht, pending); } catch (Throwable e) { ht.releaseExclusive(); throw e; } }
final void unlockToShared(_LockOwner locker, _Lock lock) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { lock.unlockToShared(locker, ht); } catch (Throwable e) { ht.releaseExclusive(); throw e; } }
/** * _Lock acquisition used by recovery. * * @param lock _Lock instance to insert, unless another already exists. The mIndexId, * mKey, and mHashCode fields must be set. */ final LockResult lockExclusive(_Lock lock, long nanosTimeout) throws LockFailureException { LockResult result = mManager.getLockHT(lock.mHashCode) .tryLockExclusive(this, lock, nanosTimeout); if (result.isHeld()) { return result; } throw failed(TYPE_EXCLUSIVE, result, nanosTimeout, lock.mHashCode); }
final void unlock(_LockOwner locker, _Lock lock) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { lock.unlock(locker, ht); } catch (Throwable e) { ht.releaseExclusive(); throw e; } }
final _Locker lockExclusiveLocal(long indexId, byte[] key, int hash) throws LockFailureException { _Locker locker = localLocker(); LockResult result = getLockHT(hash) .tryLock(TYPE_EXCLUSIVE, locker, indexId, key, hash, mDefaultTimeoutNanos); if (result.isHeld()) { return locker; } throw locker.failed(TYPE_EXCLUSIVE, result, mDefaultTimeoutNanos); }
/** * @param lockType TYPE_SHARED, TYPE_UPGRADABLE, or TYPE_EXCLUSIVE */ final LockResult lock(int lockType, long indexId, byte[] key, int hash, long nanosTimeout) throws LockFailureException { LockResult result = manager().getLockHT(hash) .tryLock(lockType, this, indexId, key, hash, nanosTimeout); if (result.isHeld()) { return result; } throw failed(lockType, result, nanosTimeout); }
final void unlock(_LockOwner locker, _Lock lock) { LockHT ht = getLockHT(lock.mHashCode); ht.acquireExclusive(); try { if (lock.unlock(locker, ht)) { ht.remove(lock); } } finally { ht.releaseExclusive(); } }
final _Locker lockExclusiveLocal(long indexId, byte[] key, int hash) throws LockFailureException { _Locker locker = localLocker(); LockResult result = getLockHT(hash) .tryLock(TYPE_EXCLUSIVE, locker, indexId, key, hash, mDefaultTimeoutNanos); if (result.isHeld()) { return locker; } throw locker.failed(TYPE_EXCLUSIVE, result, mDefaultTimeoutNanos, hash); }
final _Locker lockSharedLocal(long indexId, byte[] key, int hash) throws LockFailureException { _Locker locker = localLocker(); LockResult result = getLockHT(hash) .tryLock(TYPE_SHARED, locker, indexId, key, hash, mDefaultTimeoutNanos); if (result.isHeld()) { return locker; } throw locker.failed(TYPE_SHARED, result, mDefaultTimeoutNanos); }
final _Locker lockSharedLocal(long indexId, byte[] key, int hash) throws LockFailureException { _Locker locker = localLocker(); LockResult result = getLockHT(hash) .tryLock(TYPE_SHARED, locker, indexId, key, hash, mDefaultTimeoutNanos); if (result.isHeld()) { return locker; } throw locker.failed(TYPE_SHARED, result, mDefaultTimeoutNanos); }
final _Locker lockExclusiveLocal(long indexId, byte[] key, int hash) throws LockFailureException { _Locker locker = localLocker(); LockResult result = getLockHT(hash) .tryLock(TYPE_EXCLUSIVE, locker, indexId, key, hash, mDefaultTimeoutNanos); if (result.isHeld()) { return locker; } throw locker.failed(TYPE_EXCLUSIVE, result, mDefaultTimeoutNanos); }
final _Locker lockSharedLocal(long indexId, byte[] key, int hash) throws LockFailureException { _Locker locker = localLocker(); LockResult result = getLockHT(hash) .tryLock(TYPE_SHARED, locker, indexId, key, hash, mDefaultTimeoutNanos); if (result.isHeld()) { return locker; } throw locker.failed(TYPE_SHARED, result, mDefaultTimeoutNanos, hash); }
final LockResult check(_LockOwner locker, long indexId, byte[] key, int hash) { LockHT ht = getLockHT(hash); ht.acquireShared(); try { _Lock lock = ht.lockFor(indexId, key, hash); return lock == null ? LockResult.UNOWNED : lock.check(locker); } finally { ht.releaseShared(); } }
final LockResult check(_LockOwner locker, long indexId, byte[] key, int hash) { LockHT ht = getLockHT(hash); ht.acquireShared(); try { _Lock lock = ht.lockFor(indexId, key, hash); return lock == null ? LockResult.UNOWNED : lock.check(locker); } finally { ht.releaseShared(); } }
final LockResult check(_LockOwner locker, long indexId, byte[] key, int hash) { LockHT ht = getLockHT(hash); ht.acquireShared(); try { _Lock lock = ht.lockFor(indexId, key, hash); return lock == null ? LockResult.UNOWNED : lock.check(locker); } finally { ht.releaseShared(); } }