[infinispan-commits] Infinispan SVN: r1536 - in trunk/core/src: main/java/org/infinispan/util/concurrent/locks and 2 other directories.
infinispan-commits at lists.jboss.org
infinispan-commits at lists.jboss.org
Tue Feb 23 09:31:26 EST 2010
Author: galder.zamarreno at jboss.com
Date: 2010-02-23 09:31:25 -0500 (Tue, 23 Feb 2010)
New Revision: 1536
Modified:
trunk/core/src/main/java/org/infinispan/loaders/decorators/AsyncStore.java
trunk/core/src/main/java/org/infinispan/util/concurrent/locks/DeadlockDetectingLockManager.java
trunk/core/src/main/java/org/infinispan/util/concurrent/locks/LockManagerImpl.java
trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractPerEntryLockContainer.java
trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractStripedLockContainer.java
trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/LockContainer.java
trunk/core/src/test/java/org/infinispan/util/DeadlockDetectingLockManagerTest.java
Log:
[ISPN-351] (LockContainer.acquireLock() to return Lock instead of boolean?) Done.
Modified: trunk/core/src/main/java/org/infinispan/loaders/decorators/AsyncStore.java
===================================================================
--- trunk/core/src/main/java/org/infinispan/loaders/decorators/AsyncStore.java 2010-02-23 14:13:32 UTC (rev 1535)
+++ trunk/core/src/main/java/org/infinispan/loaders/decorators/AsyncStore.java 2010-02-23 14:31:25 UTC (rev 1536)
@@ -340,7 +340,7 @@
// map for later processing and we don't wanna do it in such way that we override a newer value that might
// have been enqueued by a user thread.
for (Object key : swap.keySet()) {
- boolean acquired = lockContainer.acquireLock(key, 0, TimeUnit.NANOSECONDS);
+ boolean acquired = lockContainer.acquireLock(key, 0, TimeUnit.NANOSECONDS) != null;
if (trace) log.trace("Lock for key {0} was acquired={1}", key, acquired);
if (!acquired) {
Modification prev = swap.remove(key);
Modified: trunk/core/src/main/java/org/infinispan/util/concurrent/locks/DeadlockDetectingLockManager.java
===================================================================
--- trunk/core/src/main/java/org/infinispan/util/concurrent/locks/DeadlockDetectingLockManager.java 2010-02-23 14:13:32 UTC (rev 1535)
+++ trunk/core/src/main/java/org/infinispan/util/concurrent/locks/DeadlockDetectingLockManager.java 2010-02-23 14:31:25 UTC (rev 1536)
@@ -57,7 +57,7 @@
final long start = System.currentTimeMillis();
long now;
while ((now = System.currentTimeMillis()) < (start + lockTimeout)) {
- if (lockContainer.acquireLock(key, spinDuration, MILLISECONDS)) {
+ if (lockContainer.acquireLock(key, spinDuration, MILLISECONDS) != null) {
if (trace) log.trace("successfully acquired lock on " + key + ", returning ...");
return true;
} else {
@@ -80,7 +80,7 @@
}
}
} else {
- if (lockContainer.acquireLock(key, lockTimeout, MILLISECONDS)) {
+ if (lockContainer.acquireLock(key, lockTimeout, MILLISECONDS) != null) {
return true;
}
}
@@ -138,7 +138,7 @@
if (remainingLockingTime < 0)
throw new IllegalStateException("No remaining time!!! The outer while condition MUST make sure this always stands true!");
if (trace) log.trace("trying to lock for the remaining time: " + remainingLockingTime + " millis ");
- return lockContainer.acquireLock(key, remainingLockingTime, MILLISECONDS);
+ return lockContainer.acquireLock(key, remainingLockingTime, MILLISECONDS) != null;
}
public void setExposeJmxStats(boolean exposeJmxStats) {
Modified: trunk/core/src/main/java/org/infinispan/util/concurrent/locks/LockManagerImpl.java
===================================================================
--- trunk/core/src/main/java/org/infinispan/util/concurrent/locks/LockManagerImpl.java 2010-02-23 14:13:32 UTC (rev 1535)
+++ trunk/core/src/main/java/org/infinispan/util/concurrent/locks/LockManagerImpl.java 2010-02-23 14:31:25 UTC (rev 1536)
@@ -79,7 +79,7 @@
public boolean lockAndRecord(Object key, InvocationContext ctx) throws InterruptedException {
long lockTimeout = getLockAcquisitionTimeout(ctx);
if (trace) log.trace("Attempting to lock {0} with acquisition timeout of {1} millis", key, lockTimeout);
- if (lockContainer.acquireLock(key, lockTimeout, MILLISECONDS)) {
+ if (lockContainer.acquireLock(key, lockTimeout, MILLISECONDS) != null) {
// successfully locked!
if (trace) log.trace("Successfully acquired lock!");
return true;
Modified: trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractPerEntryLockContainer.java
===================================================================
--- trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractPerEntryLockContainer.java 2010-02-23 14:13:32 UTC (rev 1535)
+++ trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractPerEntryLockContainer.java 2010-02-23 14:31:25 UTC (rev 1536)
@@ -39,7 +39,7 @@
return locks.size();
}
- public boolean acquireLock(Object key, long timeout, TimeUnit unit) throws InterruptedException {
+ public Lock acquireLock(Object key, long timeout, TimeUnit unit) throws InterruptedException {
while (true) {
Lock lock = getLock(key);
if (lock.tryLock(timeout, unit)) {
@@ -50,11 +50,11 @@
lock.unlock();
} else {
// we got the right lock.
- return true;
+ return lock;
}
} else {
// we couldn't acquire the lock within the timeout period
- return false;
+ return null;
}
}
}
Modified: trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractStripedLockContainer.java
===================================================================
--- trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractStripedLockContainer.java 2010-02-23 14:13:32 UTC (rev 1535)
+++ trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/AbstractStripedLockContainer.java 2010-02-23 14:31:25 UTC (rev 1536)
@@ -24,6 +24,7 @@
import net.jcip.annotations.ThreadSafe;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
/**
* A container for locks. Used with lock striping.
@@ -75,8 +76,9 @@
protected abstract void initLocks(int numLocks);
- public boolean acquireLock(Object key, long timeout, TimeUnit unit) throws InterruptedException {
- return getLock(key).tryLock(timeout, unit);
+ public Lock acquireLock(Object key, long timeout, TimeUnit unit) throws InterruptedException {
+ Lock lock = getLock(key);
+ return lock.tryLock(timeout, unit) ? lock : null;
}
public void releaseLock(Object key) {
Modified: trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/LockContainer.java
===================================================================
--- trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/LockContainer.java 2010-02-23 14:13:32 UTC (rev 1535)
+++ trunk/core/src/main/java/org/infinispan/util/concurrent/locks/containers/LockContainer.java 2010-02-23 14:31:25 UTC (rev 1536)
@@ -41,7 +41,22 @@
*/
int size();
- boolean acquireLock(Object key, long timeout, TimeUnit unit) throws InterruptedException;
+ /**
+ * Attempts to acquire a lock for the given object within certain time boundaries defined by the timeout and
+ * time unit parameters.
+ *
+ * @param key Object to acquire lock on
+ * @param timeout Time after which the lock acquisition will fail
+ * @param unit Time unit of the given timeout
+ * @return If lock was acquired it returns the corresponding Lock object. If lock was not acquired, it returns null
+ * @throws InterruptedException If the lock acquisition was interrupted
+ */
+ Lock acquireLock(Object key, long timeout, TimeUnit unit) throws InterruptedException;
+ /**
+ * Release lock on the given key.
+ *
+ * @param key Object on which lock is to be removed
+ */
void releaseLock(Object key);
}
Modified: trunk/core/src/test/java/org/infinispan/util/DeadlockDetectingLockManagerTest.java
===================================================================
--- trunk/core/src/test/java/org/infinispan/util/DeadlockDetectingLockManagerTest.java 2010-02-23 14:13:32 UTC (rev 1535)
+++ trunk/core/src/test/java/org/infinispan/util/DeadlockDetectingLockManagerTest.java 2010-02-23 14:31:25 UTC (rev 1536)
@@ -1,9 +1,11 @@
package org.infinispan.util;
import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.classextension.EasyMock.replay;
import static org.easymock.classextension.EasyMock.verify;
+
import org.infinispan.config.Configuration;
import org.infinispan.context.InvocationContext;
import org.infinispan.context.impl.NonTxInvocationContext;
@@ -17,6 +19,7 @@
import org.testng.annotations.Test;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
/**
* Tests functionality in {@link org.infinispan.util.concurrent.locks.DeadlockDetectingLockManager}.
@@ -43,9 +46,11 @@
public void testNoTransaction() throws Exception {
InvocationContext nonTx = new NonTxInvocationContext();
-
- expect(lc.acquireLock("k",config.getLockAcquisitionTimeout(), TimeUnit.MILLISECONDS)).andReturn(Boolean.TRUE);
- expect(lc.acquireLock("k",config.getLockAcquisitionTimeout(), TimeUnit.MILLISECONDS)).andReturn(false);
+
+// expect(lc.acquireLock("k",config.getLockAcquisitionTimeout(), TimeUnit.MILLISECONDS)).andReturn(EasyMock.<Lock>anyObject());
+ Lock mockLock = createNiceMock(Lock.class);
+ expect(lc.acquireLock("k",config.getLockAcquisitionTimeout(), TimeUnit.MILLISECONDS)).andReturn(mockLock);
+ expect(lc.acquireLock("k",config.getLockAcquisitionTimeout(), TimeUnit.MILLISECONDS)).andReturn(null);
replay(lc);
assert lockManager.lockAndRecord("k",nonTx);
assert !lockManager.lockAndRecord("k",nonTx);
@@ -56,10 +61,11 @@
InvocationContext localTxContext = new LocalTxInvocationContext();
//this makes sure that we cannot acquire lock from the first try
- expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(Boolean.FALSE);
+ expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(null);
lockManager.setOwner(Thread.currentThread() );
//next lock acquisition will succeed
- expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(Boolean.TRUE);
+ Lock mockLock = createNiceMock(Lock.class);
+ expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(mockLock);
replay(lc);
assert lockManager.lockAndRecord("k", localTxContext);
@@ -81,8 +87,9 @@
assert ddgt.thisWillInterrupt(lockOwner);
//this makes sure that we cannot acquire lock from the first try
- expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(Boolean.FALSE);
- expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(Boolean.TRUE);
+ expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(null);
+ Lock mockLock = createNiceMock(Lock.class);
+ expect(lc.acquireLock("k", SPIN_DURATION, TimeUnit.MILLISECONDS)).andReturn(mockLock);
lockOwner.setRemote(false);
lockManager.setOwner(lockOwner);
lockManager.setOwnsLock(true);
More information about the infinispan-commits
mailing list