S
- An implementation-specific type holding information about a single
lock; see ConsistentKeyLockStatus
for an examplepublic abstract class AbstractLocker<S extends LockStatus> extends Object implements Locker
LocalLockMediator
but delegates inter-process lock resolution
to its subclasses.ConsistentKeyLocker
Modifier and Type | Class and Description |
---|---|
static class |
AbstractLocker.Builder<S,B extends AbstractLocker.Builder<S,B>>
Abstract builder for this Locker implementation.
|
Modifier and Type | Field and Description |
---|---|
protected LocalLockMediator<StoreTransaction> |
llm
Resolves lock contention by multiple threads.
|
protected Duration |
lockExpire
The amount of time, in
times .getUnit() , that may pass
after writing a lock before it is considered to be invalid and
automatically unlocked. |
protected LockerState<S> |
lockState
Stores all information about all locks this implementation has taken on
behalf of any
StoreTransaction . |
protected org.slf4j.Logger |
log |
protected StaticBuffer |
rid
Uniquely identifies a process within a domain (or across all domains,
though only intra-domain uniqueness is required)
|
protected ConsistentKeyLockerSerializer |
serializer
This is sort-of Cassandra/HBase specific.
|
protected TimestampProvider |
times
Sole source of time.
|
Constructor and Description |
---|
AbstractLocker(StaticBuffer rid,
TimestampProvider times,
ConsistentKeyLockerSerializer serializer,
LocalLockMediator<StoreTransaction> llm,
LockerState<S> lockState,
Duration lockExpire,
org.slf4j.Logger log) |
Modifier and Type | Method and Description |
---|---|
void |
checkLocks(StoreTransaction tx)
Verify that all previous
Locker.writeLock(KeyColumn, StoreTransaction)
calls with tx actually succeeded. |
protected abstract void |
checkSingleLock(KeyColumn lockID,
S lockStatus,
StoreTransaction tx)
Try to verify that the lock identified by
lockID is already held
by tx . |
void |
deleteLocks(StoreTransaction tx)
Release every lock currently held by
tx . |
protected abstract void |
deleteSingleLock(KeyColumn lockID,
S lockStatus,
StoreTransaction tx)
Try to unlock/release/delete the lock identified by
lockID and
both held by and verified for tx . |
void |
writeLock(KeyColumn lockID,
StoreTransaction tx)
Attempt to acquire/take/claim/write the lock named by
lockID . |
protected abstract S |
writeSingleLock(KeyColumn lockID,
StoreTransaction tx)
Try to take/acquire/write/claim a lock uniquely identified within this
Locker by the lockID argument on behalf of tx . |
protected final StaticBuffer rid
protected final TimestampProvider times
TimestampProvider.getUnit()
. Furthermore, if the locking backend
allows the client to set a timestamp on writes, those timestamps should
be in the same units.
Don't call System.currentTimeMillis()
or
System.nanoTime()
directly. Use only this object. This object is
replaced with a mock during testing to give tests exact control over the
flow of time.
protected final ConsistentKeyLockerSerializer serializer
KeyColumn
arguments into a single StaticBuffer containing the key
followed by the column and vice-versa.protected final LocalLockMediator<StoreTransaction> llm
protected final LockerState<S extends LockStatus> lockState
StoreTransaction
. It is parameterized in a type
specific to the concrete subclass, so that concrete implementations can
store information specific to their locking primitives.protected final Duration lockExpire
times
.getUnit()
, that may pass
after writing a lock before it is considered to be invalid and
automatically unlocked.protected final org.slf4j.Logger log
public AbstractLocker(StaticBuffer rid, TimestampProvider times, ConsistentKeyLockerSerializer serializer, LocalLockMediator<StoreTransaction> llm, LockerState<S> lockState, Duration lockExpire, org.slf4j.Logger log)
protected abstract S writeSingleLock(KeyColumn lockID, StoreTransaction tx) throws Throwable
Locker
by the lockID
argument on behalf of tx
.lockID
- identifies the locktx
- identifies the process claiming this lockLockStatus
implementation on successful lock acquisitionThrowable
- if the lock could not be taken/acquired/written/claimed or
the attempted write encountered an errorprotected abstract void checkSingleLock(KeyColumn lockID, S lockStatus, StoreTransaction tx) throws Throwable
lockID
is already held
by tx
. The lockStatus
argument refers to the object
returned by a previous call to
writeSingleLock(KeyColumn, StoreTransaction)
. This should be a
read-only operation: return if the lock is already held, but this method
finds that it is not held, then throw an exception instead of trying to
acquire it.
This method is only useful with nonblocking locking implementations try
to lock and then check the outcome of the attempt in two separate stages.
For implementations that build writeSingleLock(...)
on a
synchronous locking primitive, such as a blocking lock()
method
or a blocking semaphore p()
, this method is redundant with
writeSingleLock(...)
and may unconditionally return true.
lockID
- identifies the lock to checklockStatus
- the result of a prior successful writeSingleLock(...)
call on this lockID
and tx
tx
- identifies the process claiming this lockThrowable
- if the lock fails the check or if the attempted check
encountered an errorprotected abstract void deleteSingleLock(KeyColumn lockID, S lockStatus, StoreTransaction tx) throws Throwable
lockID
and
both held by and verified for tx
. This method is only called with
arguments for which writeSingleLock(KeyColumn, StoreTransaction)
and checkSingleLock(KeyColumn, LockStatus, StoreTransaction)
both returned successfully (i.e. without exceptions).lockID
- identifies the lock to releaselockStatus
- the result of a prior successful writeSingleLock(...)
followed by a successful checkSingleLock(...)
tx
- identifies the process that wrote and checked this lockThrowable
- if the lock could not be released/deleted or if the attempted
delete encountered an errorpublic void writeLock(KeyColumn lockID, StoreTransaction tx) throws TemporaryLockingException, PermanentLockingException
Locker
lockID
.
Returns on success and throws an exception on failure.
writeLock
in interface Locker
lockID
- the lock to acquiretx
- the transaction attempting to acquire the lockTemporaryLockingException
- a failure likely to disappear if the call is retriedPermanentLockingException
- a failure unlikely to disappear if the call is retriedpublic void checkLocks(StoreTransaction tx) throws TemporaryLockingException, PermanentLockingException
Locker
Locker.writeLock(KeyColumn, StoreTransaction)
calls with tx
actually succeeded.
Returns on success and throws an exception on failure.
checkLocks
in interface Locker
tx
- the transaction attempting to check the result of previous
writeLock(..., tx)
calls in which it was the
tx
argumentTemporaryLockingException
- a failure likely to disappear if the call is retriedPermanentLockingException
- a failure unlikely to disappear if the call is retriedpublic void deleteLocks(StoreTransaction tx) throws TemporaryLockingException, PermanentLockingException
Locker
tx
.
Returns on success and throws an exception on failure.
deleteLocks
in interface Locker
tx
- the transaction attempting to delete locks taken in previous
writeLock(..., tx)
calls in which it was the
tx
argumentTemporaryLockingException
- a failure likely to disappear if the call is retriedPermanentLockingException
- a failure unlikely to disappear if the call is retriedCopyright © 2012–2024. All rights reserved.