Java TemporaryLockingException类代码示例

import com.thinkaurelius.titan.diskstorage.locking.TemporaryLockingException; //导入依赖的package包/类
private void tryLocks(KeyColumnValueStore s1,
                      StoreTransaction tx1, KeyColumnValueStore s2,
                      StoreTransaction tx2, boolean detectLocally) throws BackendException, InterruptedException {

    s1.acquireLock(k, k, null, tx1);

    // Require local lock contention, if requested by our caller
    // Remote lock contention is checked by separate cases
    if (detectLocally) {
        try {
            s2.acquireLock(k, k, null, tx2);
            Assert.fail("Expected lock contention between transactions did not occur");
        } catch (BackendException e) {
            Assert.assertTrue(e instanceof PermanentLockingException || e instanceof TemporaryLockingException);
        }
    }

    // Let the original lock expire
    Thread.sleep(EXPIRE_MS + 100L);

    // This should succeed now that the original lock is expired
    s2.acquireLock(k, k, null, tx2);

    // Mutate to check for remote contention
    s2.mutate(k, Arrays.<Entry>asList(StaticArrayEntry.of(c2, v2)), NO_DELETIONS, tx2);

}
 

import com.thinkaurelius.titan.diskstorage.locking.TemporaryLockingException; //导入依赖的package包/类
@Override
public void run() {

    // Catch & log exceptions
    for (int opIndex = 0; opIndex < opCount; opIndex++) {

        StoreTransaction tx = null;
        try {
            tx = newTransaction(manager);
            store.acquireLock(toLock, toLock, null, tx);
            store.mutate(toLock, ImmutableList.<Entry>of(), Arrays.asList(toLock), tx);
            tx.commit();
            succeeded++;
        } catch (TemporaryLockingException e) {
            temporaryFailures++;
        } catch (Throwable t) {
            log.error("Unexpected locking-related exception on iteration " + (opIndex + 1) + "/" + opCount, t);
        }
    }

    /*
     * This latch is the only thing guaranteeing that succeeded's true
     * value is observable by other threads once we're done with run()
     * and the latch's await() method returns.
     */
    doneLatch.countDown();
}
 

import com.thinkaurelius.titan.diskstorage.locking.TemporaryLockingException; //导入依赖的package包/类
@Override
public void writeLock(KeyColumn lockID, StoreTransaction tx) throws TemporaryLockingException, PermanentLockingException {
    if (errorOnLock)
        throw new UnsupportedOperationException("Locking is not supported!");
}
 

import com.thinkaurelius.titan.diskstorage.locking.TemporaryLockingException; //导入依赖的package包/类
@Override
public void checkLocks(StoreTransaction tx) throws TemporaryLockingException, PermanentLockingException {
    //Do nothing since no locks where written
}
 

import com.thinkaurelius.titan.diskstorage.locking.TemporaryLockingException; //导入依赖的package包/类
@Override
public void deleteLocks(StoreTransaction tx) throws TemporaryLockingException, PermanentLockingException {
    //Do nothing since no locks where written
}