@Override public void unlock() { lock.unlock(); if (hook != null) { hook.lockReleased(this); } }
@Override public void lockInterruptibly() throws InterruptedException { if (hook != null) { hook.attemptingAcquisition(this); } lock.lockInterruptibly(); if (hook != null) { hook.lockAcquired(this); } }
@Override public void lock() { if (hook != null) { hook.attemptingAcquisition(this); } lock.lock(); if (hook != null) { hook.lockAcquired(this); } }
@Override public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { if (hook != null) { hook.attemptingAcquisition(this); } boolean result = lock.tryLock(timeout, unit); if (result && (hook != null)) { hook.lockAcquired(this); } return result; }
@Override public boolean tryLock() { if (hook != null) { hook.attemptingAcquisition(this); } boolean result = lock.tryLock(); if (result && (hook != null)) { hook.lockAcquired(this); } return result; }
@Override public int hashCode() { List<Object> list = new ArrayList<Object>(); boolean present_lockid = true; list.add(present_lockid); if (present_lockid) list.add(lockid); boolean present_dbname = true && (isSetDbname()); list.add(present_dbname); if (present_dbname) list.add(dbname); boolean present_tablename = true && (isSetTablename()); list.add(present_tablename); if (present_tablename) list.add(tablename); boolean present_partname = true && (isSetPartname()); list.add(present_partname); if (present_partname) list.add(partname); boolean present_state = true && (isSetState()); list.add(present_state); if (present_state) list.add(state.getValue()); boolean present_type = true && (isSetType()); list.add(present_type); if (present_type) list.add(type.getValue()); boolean present_txnid = true && (isSetTxnid()); list.add(present_txnid); if (present_txnid) list.add(txnid); boolean present_lastheartbeat = true; list.add(present_lastheartbeat); if (present_lastheartbeat) list.add(lastheartbeat); boolean present_acquiredat = true && (isSetAcquiredat()); list.add(present_acquiredat); if (present_acquiredat) list.add(acquiredat); boolean present_user = true && (isSetUser()); list.add(present_user); if (present_user) list.add(user); boolean present_hostname = true && (isSetHostname()); list.add(present_hostname); if (present_hostname) list.add(hostname); return list.hashCode(); }
/** * Attempt to acquire a lock of <i>type</i> on <i>nodeId</i>. If the lock acquisition would result * in a deadlock, throw an exception.<br> * If the requested lock is not currently available, block until it is or until timeout * milliseconds have elapsed.<br> * If a lock of <i>type</i> is already held, return EXISTING.<br> * If a WRITE lock is held and a READ lock is requested, return PROMOTION.<br> * If a lock request is for a lock that is not currently held, return either NEW or DENIED * depending on whether the lock is granted or not.<br> * * @param nodeId The NodeId to lock. * @param locker The Locker to lock this on behalf of. * @param type The lock type requested. * @param timeout milliseconds to time out after if lock couldn't be obtained. 0 means block * indefinitely. Not used if nonBlockingRequest is true. * @param nonBlockingRequest if true, means don't block if lock can't be acquired, and ignore the * timeout parameter. * @return a LockGrantType indicating whether the request was fulfilled or not. LockGrantType.NEW * means the lock grant was fulfilled and the caller did not previously hold the lock. * PROMOTION means the lock was granted and it was a promotion from READ to WRITE. EXISTING * means the lock was already granted (not a promotion). DENIED means the lock was not granted * because the timeout passed without acquiring the lock or timeout was 0 and the lock was not * immediately available. * @throws LockConflictException if lock could not be acquired. * @throws IllegalArgumentException via db/cursor read/write methods, if non-transactional access * to a replicated environment is attempted, and read-uncommitted is not specified. */ public LockGrantType lock( long nodeId, Locker locker, LockType type, long timeout, boolean nonBlockingRequest, DatabaseImpl database) throws LockConflictException, DatabaseException { assert timeout >= 0; /* No lock needed for dirty-read, return as soon as possible. */ if (type == LockType.NONE) { return LockGrantType.NONE_NEEDED; } /* * Assert that a replication-defined locker is used for locks on * replicated databases. Two cases are exempt from this rule: * - Only NameLNs that identify replicated DBs are replicated, not * all NameLNs in the naming DB, so the naming DB is exempt. * - Non-preemption is permissible for selected internal operations * because we can ensure that they are not long running and will not * hold locks interminably. A BasicLocker is often used internally * in such cases. */ if (envImpl.isReplicated() && database != null && database.isReplicated() && !database.getId().equals(DbTree.NAME_DB_ID) && (locker.getPreemptable() || type.isWriteLock()) && !locker.isReplicationDefined()) { throw EnvironmentFailureException.unexpectedState("Locker: " + locker.getClass().getName()); } /* * Lock on locker before latching the lockTable to avoid having another * notifier perform the notify before the waiter is actually waiting. */ synchronized (locker) { LockGrantType ret = null; ret = lockInternal(nodeId, locker, type, timeout, nonBlockingRequest, database); return ret; } }
@Override public Condition newCondition() { return lock.newCondition(); }
public static LockType fromString(String lockType) { for (LockType lock : LockType.values()) if (lock.toString().equals(lockType.toLowerCase())) return lock; return null; }