9:27 a.m.
Author: manik.surtani(a)jboss.com
Date: 2008-09-25 10:27:07 -0400 (Thu, 25 Sep 2008)
New Revision: 6787
Added:
core/branches/2.2.X/src/main/java/org/jboss/cache/util/concurrent/locks/
core/branches/2.2.X/src/main/java/org/jboss/cache/util/concurrent/locks/UpgradableLock.java
Modified:
core/branches/2.2.X/src/main/java/org/jboss/cache/lock/StripedLock.java
Log:
JBCACHE-1410: JDBCCacheLoader may attempt to create a node entry in the DB twice
Modified: core/branches/2.2.X/src/main/java/org/jboss/cache/lock/StripedLock.java
===================================================================
--- core/branches/2.2.X/src/main/java/org/jboss/cache/lock/StripedLock.java 2008-09-24
11:47:40 UTC (rev 6786)
+++ core/branches/2.2.X/src/main/java/org/jboss/cache/lock/StripedLock.java 2008-09-25
14:27:07 UTC (rev 6787)
@@ -1,13 +1,31 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2000 - 2008, Red Hat Middleware LLC, and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
package org.jboss.cache.lock;
import net.jcip.annotations.ThreadSafe;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.jboss.cache.CacheException;
import org.jboss.cache.Fqn;
+import org.jboss.cache.util.concurrent.locks.UpgradableLock;
import java.util.List;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* A simple implementation of lock striping, using Fqns as the keys to lock on, primarily
used to help make
@@ -30,8 +48,7 @@
private final int lockSegmentMask;
private final int lockSegmentShift;
- final ReentrantReadWriteLock[] sharedLocks;
- private final Log log = LogFactory.getLog(StripedLock.class);
+ final UpgradableLock[] sharedLocks;
/**
* This constructor just calls {@link #StripedLock(int)} with a default concurrency
value of 20.
@@ -58,9 +75,9 @@
lockSegmentShift = 32 - tempLockSegShift;
lockSegmentMask = numLocks - 1;
- sharedLocks = new ReentrantReadWriteLock[numLocks];
+ sharedLocks = new UpgradableLock[numLocks];
- for (int i = 0; i < numLocks; i++) sharedLocks[i] = new
ReentrantReadWriteLock();
+ for (int i = 0; i < numLocks; i++) sharedLocks[i] = new UpgradableLock();
}
/**
@@ -71,15 +88,16 @@
*/
public void acquireLock(Fqn fqn, boolean exclusive)
{
- ReentrantReadWriteLock lock = getLock(fqn);
+ UpgradableLock lock = getLock(fqn);
if (exclusive)
{
- // allow for reentrancy
- lock.writeLock().lock();
+ lock.acquireWriteLockWithUpgrade();
}
else
+ {
lock.readLock().lock();
+ }
}
/**
@@ -89,28 +107,11 @@
*/
public void releaseLock(Fqn fqn)
{
- ReentrantReadWriteLock lock = getLock(fqn);
- if (lock.isWriteLockedByCurrentThread())
- {
- lock.writeLock().unlock();
- // check that we still don't have a stale WL
-// if (lock.isWriteLockedByCurrentThread() && log.isWarnEnabled())
-// log.warn("Write lock still exists on Fqn " + fqn + " for
current thread. Perhaps this was write-locked more than once?");
- }
- else
- {
- try
- {
- lock.readLock().unlock();
- }
- catch (IllegalMonitorStateException imse)
- {
- throw new CacheException("Lock is held by a different thread! Cannot be
unlocked by current thread.", imse);
- }
- }
+ UpgradableLock lock = getLock(fqn);
+ lock.unlock();
}
- final ReentrantReadWriteLock getLock(Object o)
+ final UpgradableLock getLock(Object o)
{
return sharedLocks[hashToIndex(o)];
}
@@ -160,4 +161,4 @@
{
for (Fqn f : fqns) acquireLock(f, exclusive);
}
-}
+}
\ No newline at end of file
Added:
core/branches/2.2.X/src/main/java/org/jboss/cache/util/concurrent/locks/UpgradableLock.java
===================================================================
---
core/branches/2.2.X/src/main/java/org/jboss/cache/util/concurrent/locks/UpgradableLock.java
(rev 0)
+++
core/branches/2.2.X/src/main/java/org/jboss/cache/util/concurrent/locks/UpgradableLock.java 2008-09-25
14:27:07 UTC (rev 6787)
@@ -0,0 +1,88 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2008, Red Hat Middleware LLC, and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.cache.util.concurrent.locks;
+
+import org.jboss.cache.util.concurrent.ConcurrentHashSet;
+
+import java.util.Set;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * A {@link java.util.concurrent.locks.ReentrantReadWriteLock} with support for acquiring
write locks when the current
+ * thread already has a read lock. Also supports releasing such write locks and
re-acquiring read locks in the process.
+ */
+public class UpgradableLock extends ReentrantReadWriteLock
+{
+ private final Set<Thread> upgraders = new ConcurrentHashSet<Thread>();
+
+ /**
+ * Attempts to upgrade a read lock to a write lock. If no read locks are held, a
write lock is simply attempted.
+ */
+ public void acquireWriteLockWithUpgrade()
+ {
+ boolean upgradeNeeded = true;
+ try
+ {
+ readLock().unlock();
+ }
+ catch (IllegalMonitorStateException imse)
+ {
+ // read lock was never held; no upgrading needed.
+ upgradeNeeded = false;
+ }
+
+ if (upgradeNeeded) upgraders.add(Thread.currentThread());
+
+ writeLock().lock();
+ }
+
+ /**
+ * Unlocks any locks held by the current thread. If a write lock is held, it is
released. If a read lock is held
+ * it is released. This method supports reentrant locks so unlocking repeatedly may
release >1 write lock. It
+ * also supports upgraded locks, i.e., read locks that were upgraded to write locks.
+ */
+ public void unlock()
+ {
+ if (isWriteLockedByCurrentThread())
+ {
+ writeLock().unlock();
+ Thread current;
+ if (!isWriteLockedByCurrentThread() && upgraders.contains((current =
Thread.currentThread())))
+ {
+ // re-acquire the RL.
+ readLock().lock();
+ upgraders.remove(current);
+ }
+ }
+ else
+ {
+ try
+ {
+ readLock().unlock();
+ }
+ catch (IllegalMonitorStateException imse)
+ {
+ // perhaps the RL was already released earlier?
+ }
+ }
+ }
+}
\ No newline at end of file