GH-11146: LockRegistry: prevent collision on mask

Fixes: #11146

 When a thread simultaneously holds two `JdbcLock` instances for different lock keys
that happen to map to the same bucket in the 256-slot `DefaultLockRegistry`,
the `getHoldCount() > 1` guard in `JdbcLock.unlock()` incorrectly fires.
The result is that the `APP_LOCK` database entry for the second lock is never deleted,
leaving other threads waiting indefinitely until the TTL expires.

* Use per `JdbcLock` (and `RedisLock`) instance `holdCount` property instead,
so different keys landing in the same `delegate` would still have their own hold count.

Author: artembilan

spring-integration-jdbc/src/main/java/org/springframework/integration/jdbc/lock/JdbcLockRegistry.java

@@ -173,6 +173,8 @@ private final class JdbcLock implements Lock {
 
 		private final ReentrantLock delegate;
 
+		private int holdCount;
+
 		JdbcLock(LockRepository client, Duration idleBetweenTries, String path) {
 			this.mutex = client;
 			this.idleBetweenTries = idleBetweenTries;
@@ -192,6 +194,7 @@ public void lock() {
 					while (!doLock()) {
 						Thread.sleep(this.idleBetweenTries.toMillis());
 					}
+					this.holdCount++;
 					break;
 				}
 				catch (TransientDataAccessException | TransactionTimedOutException | TransactionSystemException e) {
@@ -226,6 +229,7 @@ public void lockInterruptibly() throws InterruptedException {
 							throw new InterruptedException();
 						}
 					}
+					this.holdCount++;
 					break;
 				}
 				catch (TransientDataAccessException | TransactionTimedOutException | TransactionSystemException e) {
@@ -270,6 +274,9 @@ public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
 					if (!acquired) {
 						this.delegate.unlock();
 					}
+					else {
+						this.holdCount++;
+					}
 					return acquired;
 				}
 				catch (TransientDataAccessException | TransactionTimedOutException | TransactionSystemException e) {
@@ -295,7 +302,8 @@ public void unlock() {
 			if (!this.delegate.isHeldByCurrentThread()) {
 				throw new IllegalMonitorStateException("The current thread doesn't own mutex at " + this.path);
 			}
-			if (this.delegate.getHoldCount() > 1) {
+			if (this.holdCount > 1) {
+				this.holdCount--;
 				this.delegate.unlock();
 				return;
 			}
@@ -322,6 +330,7 @@ public void unlock() {
 				}
 			}
 			finally {
+				this.holdCount--;
 				this.delegate.unlock();
 			}
 		}

spring-integration-jdbc/src/test/java/org/springframework/integration/jdbc/lock/JdbcLockRegistryTests.java

@@ -601,6 +601,63 @@ void noSecondLockOnEviction() throws InterruptedException {
 		});
 	}
 
+	@Test
+	void sharedDelegateIsDeletedFromDbOnUnlock() throws Exception {
+		DefaultLockRepository client1 = newLockRepository();
+		DefaultLockRepository client2 = newLockRepository();
+
+		JdbcLockRegistry registry1 = new JdbcLockRegistry(client1);
+		// setCacheCapacity(2) gives mask=1 in DefaultLockRegistry → only 2 slots, guaranteed collision in ≤3 keys
+		registry1.setCacheCapacity(2);
+		JdbcLockRegistry registry2 = new JdbcLockRegistry(client2);
+
+		// Find two distinct lock keys that share the same ReentrantLock (same DefaultLockRegistry slot)
+		String keyB = null;
+		DistributedLock lockA = null;
+		DistributedLock lockB = null;
+		outer:
+		for (int i = 0; i < 10; i++) {
+			for (int j = i + 1; j < 10; j++) {
+				keyB = "key-" + j;
+				DistributedLock la = registry1.obtain("key-" + i);
+				DistributedLock lb = registry1.obtain(keyB);
+				if (TestUtils.getPropertyValue(la, "delegate") == TestUtils.getPropertyValue(lb, "delegate")) {
+
+					lockA = la;
+					lockB = lb;
+					break outer;
+				}
+			}
+		}
+		assertThat(lockA)
+				.as("Could not find two lock keys mapping to the same DefaultLockRegistry slot")
+				.isNotNull();
+
+		lockA.lock();
+		// Shared delegate: delegate.holdCount becomes 2 after this call
+		lockB.lock();
+
+		// Unlock B first — before the fix, delegate.getHoldCount()>1 short-circuited and skipped the DB delete
+		lockB.unlock();
+
+		// Another process must be able to acquire keyB immediately (its DB row must be deleted)
+		DistributedLock lockBOtherProcess = registry2.obtain(keyB);
+		assertThat(lockBOtherProcess.tryLock(500, TimeUnit.MILLISECONDS))
+				.as("DB row for '" + keyB + "' was not deleted on unlock — orphaned lock detected")
+				.isTrue();
+		lockBOtherProcess.unlock();
+
+		assertThatNoException().isThrownBy(lockA::unlock);
+	}
+
+	private DefaultLockRepository newLockRepository() {
+		DefaultLockRepository client = new DefaultLockRepository(this.dataSource);
+		client.setApplicationContext(this.context);
+		client.afterPropertiesSet();
+		client.afterSingletonsInstantiated();
+		return client;
+	}
+
 	@SuppressWarnings("unchecked")
 	private static Map<String, Lock> getRegistryLocks(JdbcLockRegistry registry) {
 		return TestUtils.getPropertyValue(registry, "locks", Map.class);

spring-integration-redis/src/main/java/org/springframework/integration/redis/util/RedisLockRegistry.java

@@ -393,6 +393,8 @@ private abstract class RedisLock implements Lock {
 
 		private final ReentrantLock localLock;
 
+		private int holdCount;
+
 		private volatile long lockedAt;
 
 		private volatile ScheduledFuture<?> renewFuture;
@@ -435,6 +437,7 @@ public final void lock() {
 			while (true) {
 				try {
 					if (tryRedisLock(-1L)) {
+						this.holdCount++;
 						return;
 					}
 				}
@@ -462,6 +465,7 @@ public final void lockInterruptibly() throws InterruptedException {
 			while (true) {
 				try {
 					if (tryRedisLock(-1L)) {
+						this.holdCount++;
 						return;
 					}
 				}
@@ -499,6 +503,9 @@ public final boolean tryLock(long time, TimeUnit unit) throws InterruptedExcepti
 				if (!acquired) {
 					this.localLock.unlock();
 				}
+				else {
+					this.holdCount++;
+				}
 				return acquired;
 			}
 			catch (Exception e) {
@@ -536,7 +543,8 @@ public final void unlock() {
 			if (!this.localLock.isHeldByCurrentThread()) {
 				throw new IllegalStateException("You do not own lock at " + this.lockKey);
 			}
-			if (this.localLock.getHoldCount() > 1) {
+			if (this.holdCount > 1) {
+				this.holdCount--;
 				this.localLock.unlock();
 				return;
 			}
@@ -581,6 +589,7 @@ public final void unlock() {
 				ReflectionUtils.rethrowRuntimeException(e);
 			}
 			finally {
+				this.holdCount--;
 				this.localLock.unlock();
 			}
 		}

spring-integration-redis/src/test/java/org/springframework/integration/redis/util/RedisLockRegistryTests.java

@@ -1066,6 +1066,54 @@ private void waitForExpire(String key) throws Exception {
 		assertThat(n < 100).as(key + " key did not expire").isTrue();
 	}
 
+	@Test
+	void sharedDelegateIsDeletedFromRedisOnUnlock() throws Exception {
+		RedisLockRegistry registry1 = new RedisLockRegistry(redisConnectionFactory, this.registryKey);
+		// setCacheCapacity(2) gives mask=1 in DefaultLockRegistry → only 2 slots, guaranteed collision in ≤3 keys
+		registry1.setCacheCapacity(2);
+		RedisLockRegistry registry2 = new RedisLockRegistry(redisConnectionFactory, this.registryKey);
+
+		// Find two distinct lock keys that share the same ReentrantLock (same DefaultLockRegistry slot)
+		String keyB = null;
+		DistributedLock lockA = null;
+		DistributedLock lockB = null;
+		outer:
+		for (int i = 0; i < 10; i++) {
+			for (int j = i + 1; j < 10; j++) {
+				DistributedLock la = registry1.obtain("key-" + i);
+				DistributedLock lb = registry1.obtain("key-" + j);
+				if (TestUtils.getPropertyValue(la, "localLock") == TestUtils.getPropertyValue(lb, "localLock")) {
+					keyB = "key-" + j;
+					lockA = la;
+					lockB = lb;
+					break outer;
+				}
+			}
+		}
+		assertThat(lockA)
+				.as("Could not find two lock keys mapping to the same DefaultLockRegistry slot")
+				.isNotNull();
+
+		lockA.lock();
+		// Shared localLock: localLock.holdCount becomes 2 after this call
+		lockB.lock();
+
+		// Unlock B first — before the fix, localLock.getHoldCount()>1 short-circuited and skipped the Redis delete
+		lockB.unlock();
+
+		// Another process must be able to acquire keyB immediately (its Redis key must be deleted)
+		DistributedLock lockBOtherProcess = registry2.obtain(keyB);
+		assertThat(lockBOtherProcess.tryLock(500, TimeUnit.MILLISECONDS))
+				.as("Redis key for '" + keyB + "' was not deleted on unlock — orphaned lock detected")
+				.isTrue();
+		lockBOtherProcess.unlock();
+
+		assertThatNoException().isThrownBy(lockA::unlock);
+
+		registry1.destroy();
+		registry2.destroy();
+	}
+
 	@SuppressWarnings("unchecked")
 	private static Map<String, Lock> getRedisLockRegistryLocks(RedisLockRegistry registry) {
 		return TestUtils.getPropertyValue(registry, "locks", Map.class);