Index: ssts-web/src/test/java/test/forgon/system/concurrent/service/OptimisticLockManagerTests.java
===================================================================
diff -u -r23803 -r23804
--- ssts-web/src/test/java/test/forgon/system/concurrent/service/OptimisticLockManagerTests.java	(.../OptimisticLockManagerTests.java)	(revision 23803)
+++ ssts-web/src/test/java/test/forgon/system/concurrent/service/OptimisticLockManagerTests.java	(.../OptimisticLockManagerTests.java)	(revision 23804)
@@ -31,7 +31,7 @@
  *
  */
 @Transactional(propagation = Propagation.NEVER)
-//@Test(singleThreaded = true)
+// @Test(singleThreaded = true)
 public class OptimisticLockManagerTests extends AbstractCSSDTest {
 
 	private static final String ENTITY_OPTIMISTICLOCKTEST = "OptimisticLockTest";
@@ -78,6 +78,7 @@
 	 */
 	@Test
 	public void test_OneTransaction_Normal() {
+		assertNoLocks();
 		{
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
@@ -114,6 +115,7 @@
 	 */
 	@Test
 	public void test_requestLockByStringIds_OneTransaction_Normal() {
+		assertNoLocks();
 		{
 			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
 					"5" });
@@ -155,6 +157,7 @@
 	 */
 	@Test
 	public void test_requestLockById_OneTransaction_RepeatRequest() {
+		assertNoLocks();
 		{
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
@@ -171,6 +174,7 @@
 	 */
 	@Test
 	public void test_requestLockByStringIds_OneTransaction_RepeatRequest() {
+		assertNoLocks();
 		{
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
@@ -185,11 +189,17 @@
 		}
 	}
 
+	private void assertNoLocks() {
+		List<OptimisticLock> allLocks_end = optimisticLockManager.getAllLocks();
+		assertEquals(allLocks_end.size(), 0);
+	}
+
 	/**
 	 * 两个事务请求锁_测试资源是否正确分配和释放
 	 */
 	@Test
 	public void test_TwoTransactions_Normal() {
+		assertNoLocks();
 		{
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
@@ -271,6 +281,7 @@
 	 */
 	@Test
 	public void test_requestLockByStringIds_TwoTransactions_Normal() {
+		assertNoLocks();
 		{
 			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
 					"5" });
@@ -358,6 +369,7 @@
 	 */
 	@Test
 	public void test_TwoEntities_TwoTransactions_Normal() {
+		assertNoLocks();
 		{
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
@@ -439,6 +451,7 @@
 	 */
 	@Test
 	public void test_requestLockByStringIds_TwoEntities_TwoTransactions_Normal() {
+		assertNoLocks();
 		{
 			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
 					"5" });
@@ -534,6 +547,7 @@
 	 */
 	@Test(expectedExceptions = OptimisticLockConflictException.class)
 	public void test_TwoTransactions_Conflict() {
+		assertNoLocks();
 		{
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
@@ -558,18 +572,93 @@
 						ENTITY_OPTIMISTICLOCKTEST);
 				assertEquals(optimisticLock.getId(), "1");
 			}
-			optimisticLockManagerTestLevel1.requestLockById(
-					ENTITY_OPTIMISTICLOCKTEST, "1", notifyObject2,
-					continueObject2);
+			try {
+				optimisticLockManagerTestLevel1.requestLockById(
+						ENTITY_OPTIMISTICLOCKTEST, "1", notifyObject2,
+						continueObject2);
+			} catch (OptimisticLockConflictException e) {
+				continueObject.setDone();
+				try {
+					thread.join();
+				} catch (InterruptedException e1) {
+					e1.printStackTrace();
+				}
+				throw e;
+			}
 			// 异常
 		}
 	}
 
 	/**
+	 * 一个事务请求锁_冲突，释放资源
+	 */
+	@Test
+	public void test_OneTransaction_Exception_ReleaseLocks() {
+		assertNoLocks();
+		{
+			try {
+				optimisticLockManagerTestLevel1
+						.test_OneTransaction_Exception_ReleaseLocks();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+		assertNoLocks();
+	}
+
+	/**
+	 * 两个事务请求锁_冲突，释放资源
+	 */
+	@Test
+	public void test_TwoTransactions_Conflict_ReleaseLocks() {
+		assertNoLocks();
+		{
+			WaitObject notifyObject = new WaitObject();
+			WaitObject continueObject = new WaitObject();
+			Thread thread = new Thread() {
+				public void run() {
+					optimisticLockManagerTestLevel1.requestLockById(
+							ENTITY_OPTIMISTICLOCKTEST, "1", notifyObject,
+							continueObject);
+				};
+			};
+			thread.start();
+			WaitObject notifyObject2 = new WaitObject();
+			WaitObject continueObject2 = new WaitObject();
+
+			notifyObject.waitForDone();
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				assertEquals(allLocks.size(), 1);
+				OptimisticLock optimisticLock = allLocks.get(0);
+				assertEquals(optimisticLock.getEntity(),
+						ENTITY_OPTIMISTICLOCKTEST);
+				assertEquals(optimisticLock.getId(), "1");
+			}
+			try {
+				optimisticLockManagerTestLevel1.requestLockById(
+						ENTITY_OPTIMISTICLOCKTEST, "1", notifyObject2,
+						continueObject2);
+			} catch (OptimisticLockConflictException e) {
+				continueObject.setDone();
+				try {
+					thread.join();
+				} catch (InterruptedException e1) {
+					e1.printStackTrace();
+				}
+			}
+			// 异常
+		}
+		assertNoLocks();
+	}
+
+	/**
 	 * 两个事务请求锁_冲突
 	 */
 	@Test(expectedExceptions = OptimisticLockConflictException.class)
 	public void test_requestLockByStringIds_TwoTransactions_Conflict() {
+		assertNoLocks();
 		{
 			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
 					"5" });
@@ -599,9 +688,19 @@
 					assertEquals(optimisticLock.getId(), ids.get(i));
 				}
 			}
-			optimisticLockManagerTestLevel1.requestLockByStringIds(
-					ENTITY_OPTIMISTICLOCKTEST, ids2, notifyObject2,
-					continueObject2);
+			try {
+				optimisticLockManagerTestLevel1.requestLockByStringIds(
+						ENTITY_OPTIMISTICLOCKTEST, ids2, notifyObject2,
+						continueObject2);
+			} catch (Exception e) {
+				continueObject.setDone();
+				try {
+					thread.join();
+				} catch (InterruptedException e1) {
+					e1.printStackTrace();
+				}
+				throw e;
+			}
 			// 异常
 		}
 	}
@@ -611,17 +710,19 @@
 	 */
 	@Test
 	public void test_NewTransaction_Normal() {
+		assertNoLocks();
 		optimisticLockManagerTestLevel1.test_NewTransaction_Normal();
 		List<OptimisticLock> allLocks_end = optimisticLockManager.getAllLocks();
 		assertEquals(allLocks_end.size(), 0);
 
 	}
-	
+
 	/**
 	 * 调用新事务，冲突
 	 */
 	@Test(expectedExceptions = OptimisticLockConflictException.class)
 	public void test_NewTransaction_Conflict() {
+		assertNoLocks();
 		optimisticLockManagerTestLevel1.test_NewTransaction_Conflict();
 		// Exception
 		assertEquals(0, 1);
Index: forgon-tools/src/main/java/com/forgon/system/concurrent/service/test/OptimisticLockManagerTestLevel1.java
===================================================================
diff -u -r23803 -r23804
--- forgon-tools/src/main/java/com/forgon/system/concurrent/service/test/OptimisticLockManagerTestLevel1.java	(.../OptimisticLockManagerTestLevel1.java)	(revision 23803)
+++ forgon-tools/src/main/java/com/forgon/system/concurrent/service/test/OptimisticLockManagerTestLevel1.java	(.../OptimisticLockManagerTestLevel1.java)	(revision 23804)
@@ -16,6 +16,7 @@
 	public void test_OneTransaction_RepeatRequest(String entity, String id,WaitObject notifyObject,WaitObject continueObject);
 	public void test_requestLockByStringIds_OneTransaction_RepeatRequest(String entity, List<String> ids,WaitObject notifyObject,WaitObject continueObject);
 	
+	public void test_OneTransaction_Exception_ReleaseLocks();
 	public void test_NewTransaction_Normal();
 	public void test_NewTransaction_Conflict();
 	
Index: forgon-tools/src/main/java/com/forgon/system/concurrent/service/test/OptimisticLockManagerTestLevel1Impl.java
===================================================================
diff -u -r23803 -r23804
--- forgon-tools/src/main/java/com/forgon/system/concurrent/service/test/OptimisticLockManagerTestLevel1Impl.java	(.../OptimisticLockManagerTestLevel1Impl.java)	(revision 23803)
+++ forgon-tools/src/main/java/com/forgon/system/concurrent/service/test/OptimisticLockManagerTestLevel1Impl.java	(.../OptimisticLockManagerTestLevel1Impl.java)	(revision 23804)
@@ -78,6 +78,20 @@
 			}
 		}
 	}
+	
+	public void test_OneTransaction_Exception_ReleaseLocks(){
+		requestLockById(ENTITY_OPTIMISTICLOCKTEST, "1", null, null);
+		{
+			List<OptimisticLock> allLocks = optimisticLockManager.getAllLocks();
+			assertEquals(allLocks.size(), 1);
+			OptimisticLock optimisticLock = allLocks.get(0);
+			assertEquals(optimisticLock.getEntity(), ENTITY_OPTIMISTICLOCKTEST);
+			assertEquals(optimisticLock.getId(), "1");
+		}
+		int i = 1/0;
+		// Exception
+		assertEquals(100, i);
+	}
 
 	public void test_NewTransaction_Normal() {
 		requestLockById(ENTITY_OPTIMISTICLOCKTEST, "1", null, null);