[Mulgara-svn] r1929 - trunk/src/jar/resolver/java/org/mulgara/resolver

[pag at mulgara.org]

Author: pag
Date: 2010-03-03 12:05:53 -0800 (Wed, 03 Mar 2010)
New Revision: 1929

Modified:
   trunk/src/jar/resolver/java/org/mulgara/resolver/StringPoolSession.java
Log:
created a new lock for managing transaction state, separate to the lock used for synchronizing between node and string pools

Modified: trunk/src/jar/resolver/java/org/mulgara/resolver/StringPoolSession.java
===================================================================
--- trunk/src/jar/resolver/java/org/mulgara/resolver/StringPoolSession.java	2010-02-17 22:45:36 UTC (rev 1928)
+++ trunk/src/jar/resolver/java/org/mulgara/resolver/StringPoolSession.java	2010-03-03 20:05:53 UTC (rev 1929)
@@ -31,6 +31,8 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.*;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 // Third party packages
 import org.apache.log4j.Logger;
@@ -129,9 +131,13 @@
 
   /** Where to store literals which won't outlive this session.  */
   private final StringPool temporaryStringPool;
-  
+
+  /** An enumeration of the various states for this session. */
   private int state;
 
+  /** A lock for managing the modification of state. */
+  private Lock stateLock = new ReentrantLock();
+
   private SimpleXAResource[] resources;
 
   private Object globalLock;
@@ -262,7 +268,8 @@
   public void prepare() throws SimpleXAResourceException {
     checkCurrentThread();
     try {
-      synchronized (globalLock) {
+      stateLock.lock();
+      try {
         if (logger.isDebugEnabled()) {
           logger.debug("Preparing phase on StringPoolSession " + System.identityHashCode(this) + " SP=" + System.identityHashCode(persistentStringPool));
         }
@@ -276,6 +283,8 @@
     
         persistentStringPool.prepare();  // calls prepare on the node pool
         for (int i = 0; i < resources.length; i++) resources[i].prepare();
+      } finally {
+        stateLock.unlock();
       }
     } finally {
       releaseCurrentThread();
@@ -286,7 +295,8 @@
   public void commit() throws SimpleXAResourceException {
     checkCurrentThread();
     try {
-      synchronized (globalLock) {
+      stateLock.lock();
+      try {
         if (logger.isDebugEnabled()) {
           logger.debug("Committing phase on StringPoolSession " + System.identityHashCode(this));
         }
@@ -298,8 +308,13 @@
     
         state = COMMIT;
 
-        persistentStringPool.commit();  // calls commit() on the node pool
-        for (int i = 0; i < resources.length; i++) resources[i].commit();
+        // now holding BOTH the stateLock AND the globalLock. This should be short!
+        synchronized (globalLock) {
+          persistentStringPool.commit();  // calls commit() on the node pool
+          for (int i = 0; i < resources.length; i++) resources[i].commit();
+        }
+      } finally {
+        stateLock.unlock();
       }
     } finally {
       releaseCurrentThread();
@@ -310,7 +325,8 @@
   public void rollback() throws SimpleXAResourceException {
     checkCurrentThread();
     try {
-      synchronized (globalLock) {
+      stateLock.lock();
+      try {
         if (logger.isDebugEnabled()) {
           logger.debug("Rollback phase on StringPoolSession " + System.identityHashCode(this));
         }
@@ -320,6 +336,8 @@
         state = ROLLBACK;
         persistentStringPool.rollback();  // calls rollback on the node pool
         for (int i = 0; i < resources.length; i++) resources[i].rollback();
+      } finally {
+        stateLock.unlock();
       }
     } finally {
       releaseCurrentThread();
@@ -330,7 +348,8 @@
   public void release() throws SimpleXAResourceException {
     checkCurrentThread();
     try {
-      synchronized (globalLock) {
+      stateLock.lock();
+      try {
         if (logger.isDebugEnabled()) {
           logger.debug("Release phase on StringPoolSession " + System.identityHashCode(this));
         }
@@ -348,6 +367,8 @@
         //temporaryStringPool.release();
         //temporaryNodePool.release();
         for (int i = 0; i < resources.length; i++) resources[i].release();
+      } finally {
+        stateLock.unlock();
       }
     } finally {
       releaseCurrentThread();