/** * In order to support ReentrantLock, the TransactionContext that is going to be removed when * doing a commit may not always be at the top of a stack because an reentrant lock could issue a * lock within a synchronized block (although it is highly not recommended). Therefore, when a * commit is issued, we need to search back the stack from the top of the stack to find the * appropriate TransactionContext to be removed. Most likely, the TransactionContext to be removed * will be on the top of the stack. Therefore, the performance should be make must difference. * Only in some weird situations where reentrantLock is mixed with synchronized block will the * TransactionContext to be removed be found otherwise. */ public void commit(String lockName) throws UnlockedSharedObjectException { logCommit0(); if (isTransactionLoggingDisabled() || objectManager.isCreationInProgress()) { return; } // ClientTransaction tx = popTransaction(); ClientTransaction tx = getTransaction(); LockID lockID = lockManager.lockIDFor(lockName); if (lockID == null || lockID.isNull()) { lockID = tx.getLockID(); } boolean hasCommitted = commit(lockID, tx, false); popTransaction(lockManager.lockIDFor(lockName)); if (peekContext() != null) { if (hasCommitted) { createTxAndInitContext(); } else { // If the current transaction has not committed, we will reuse the current transaction // so that the current changes will have a chance to commit at the next commit point. tx.setTransactionContext(peekContext()); setTransaction(tx); } } }
public boolean tryBegin(String lockName, WaitInvocation timeout, int lockLevel) { logTryBegin0(lockName, lockLevel); if (isTransactionLoggingDisabled() || objectManager.isCreationInProgress()) { return true; } final TxnType txnType = getTxnTypeFromLockLevel(lockLevel); ClientTransaction currentTransaction = getTransactionOrNull(); if ((currentTransaction != null) && lockLevel == LockLevel.CONCURRENT) { // make formatter sane throw new AssertionError("Can't acquire concurrent locks in a nested lock context."); } final LockID lockID = lockManager.lockIDFor(lockName); boolean isLocked = lockManager.tryLock(lockID, timeout, lockLevel); if (!isLocked) { return isLocked; } pushTxContext(lockID, txnType); if (currentTransaction == null) { createTxAndInitContext(); } else { currentTransaction.setTransactionContext(this.peekContext()); } return isLocked; }
public boolean begin(String lockName, int lockLevel) { logBegin0(lockName, lockLevel); if (isTransactionLoggingDisabled() || objectManager.isCreationInProgress()) { return false; } final TxnType txnType = getTxnTypeFromLockLevel(lockLevel); ClientTransaction currentTransaction = getTransactionOrNull(); final LockID lockID = lockManager.lockIDFor(lockName); pushTxContext(lockID, txnType); if (currentTransaction == null) { createTxAndInitContext(); } else { currentTransaction.setTransactionContext(this.peekContext()); } lockManager.lock(lockID, lockLevel); return true; }
private void createTxAndInitContext() { ClientTransaction ctx = txFactory.newInstance(); ctx.setTransactionContext(peekContext()); setTransaction(ctx); }