Clean up LockRegistry API and some warning

Author: artembilan

spring-integration-core/src/main/java/org/springframework/integration/support/locks/DefaultLockRegistry.java

@@ -31,6 +31,7 @@
  *
  * @author Oleg Zhurakousky
  * @author Gary Russell
+ *
  * @since 2.1.1
  *
  */
@@ -41,15 +42,15 @@ public final class DefaultLockRegistry implements LockRegistry<Lock> {
 	private final int mask;
 
 	/**
-	 * Constructs a DefaultLockRegistry with the default
+	 * Construct a DefaultLockRegistry with the default
 	 * mask 0xFF with 256 locks.
 	 */
 	public DefaultLockRegistry() {
 		this(0xFF); // NOSONAR magic number
 	}
 
 	/**
-	 * Constructs a DefaultLockRegistry with the supplied
+	 * Construct a DefaultLockRegistry with the supplied
 	 * mask - the mask must have a value Math.pow(2, n) - 1 where n
 	 * is 1 to 31, creating a hash of Math.pow(2, n) locks.
 	 * <p> Examples:
@@ -61,7 +62,8 @@ public DefaultLockRegistry() {
 	 */
 	public DefaultLockRegistry(int mask) {
 		String bits = Integer.toBinaryString(mask);
-		Assert.isTrue(bits.length() < 32 && (mask == 0 || bits.lastIndexOf('0') < bits.indexOf('1')), "Mask must be a power of 2 - 1"); // NOSONAR magic number
+		Assert.isTrue(bits.length() < 32 && (mask == 0 || bits.lastIndexOf('0') < bits.indexOf('1')),
+				"Mask must be a power of 2 - 1"); // NOSONAR magic number
 		this.mask = mask;
 		int arraySize = this.mask + 1;
 		this.lockTable = new ReentrantLock[arraySize];
@@ -71,14 +73,14 @@ public DefaultLockRegistry(int mask) {
 	}
 
 	/**
-	 * Obtains a lock by masking the lockKey's hashCode() with
+	 * Obtain a lock by masking the lockKey's hashCode() with
 	 * the mask and using the result as an index to the lock table.
 	 * @param lockKey the object used to derive the lock index.
 	 */
 	@Override
 	public Lock obtain(Object lockKey) {
 		Assert.notNull(lockKey, "'lockKey' must not be null");
-		Integer lockIndex = lockKey.hashCode() & this.mask;
+		int lockIndex = lockKey.hashCode() & this.mask;
 		return this.lockTable[lockIndex];
 	}
 

spring-integration-core/src/test/java/org/springframework/integration/handler/advice/LockRequestHandlerAdviceTests.java

@@ -114,7 +114,7 @@ void verifyLockAroundHandler() throws ExecutionException, InterruptedException,
 	public static class Config {
 
 		@Bean
-		LockRegistry lockRegistry() {
+		LockRegistry<?> lockRegistry() {
 			return new DefaultLockRegistry();
 		}
 
@@ -124,7 +124,7 @@ QueueChannel discardChannel() {
 		}
 
 		@Bean
-		LockRequestHandlerAdvice lockRequestHandlerAdvice(LockRegistry lockRegistry, QueueChannel discardChannel) {
+		LockRequestHandlerAdvice lockRequestHandlerAdvice(LockRegistry<?> lockRegistry, QueueChannel discardChannel) {
 			LockRequestHandlerAdvice lockRequestHandlerAdvice =
 					new LockRequestHandlerAdvice(lockRegistry, (message) -> message.getHeaders().get(LOCK_KEY_HEADER));
 			lockRequestHandlerAdvice.setDiscardChannel(discardChannel);

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

@@ -16,6 +16,7 @@
 
 package org.springframework.integration.jdbc.lock;
 
+import java.io.Serial;
 import java.time.Duration;
 import java.util.ConcurrentModificationException;
 import java.util.LinkedHashMap;
@@ -73,6 +74,9 @@ public class JdbcLockRegistry implements ExpirableLockRegistry<DistributedLock>,
 	private final Map<String, JdbcLock> locks =
 			new LinkedHashMap<>(16, 0.75F, true) {
 
+				@Serial
+				private static final long serialVersionUID = -8345579941944883141L;
+
 				@Override
 				protected boolean removeEldestEntry(Entry<String, JdbcLock> eldest) {
 					return size() > JdbcLockRegistry.this.cacheCapacity;

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

@@ -121,6 +121,7 @@ void testLockInterruptibly() throws Exception {
 	}
 
 	@Test
+	@SuppressWarnings("unchecked")
 	void testLockWithCustomTtl() throws Exception {
 		JdbcLockRegistry lockRegistry = new JdbcLockRegistry(client, Duration.ofMillis(100));
 		long sleepTimeLongerThanDefaultTTL = 110;
@@ -141,6 +142,7 @@ void testLockWithCustomTtl() throws Exception {
 	}
 
 	@Test
+	@SuppressWarnings("unchecked")
 	void testTryLockWithCustomTtl() throws Exception {
 		JdbcLockRegistry lockRegistry = new JdbcLockRegistry(client, Duration.ofMillis(100));
 		long sleepTimeLongerThanDefaultTTL = 110;
@@ -401,15 +403,15 @@ void testLockRenewWithCustomTtl() throws InterruptedException {
 
 	@Test
 	void concurrentObtainCapacityTest() throws InterruptedException {
-		final int KEY_CNT = 500;
-		final int CAPACITY_CNT = 179;
-		final int THREAD_CNT = 4;
+		final int keyCnt = 500;
+		final int capacityCnt = 179;
+		final int threadCnt = 4;
 
-		final CountDownLatch countDownLatch = new CountDownLatch(THREAD_CNT);
-		registry.setCacheCapacity(CAPACITY_CNT);
-		final ExecutorService executorService = Executors.newFixedThreadPool(THREAD_CNT);
+		final CountDownLatch countDownLatch = new CountDownLatch(threadCnt);
+		registry.setCacheCapacity(capacityCnt);
+		final ExecutorService executorService = Executors.newFixedThreadPool(threadCnt);
 
-		for (int i = 0; i < KEY_CNT; i++) {
+		for (int i = 0; i < keyCnt; i++) {
 			int finalI = i;
 			executorService.submit(() -> {
 				countDownLatch.countDown();
@@ -429,32 +431,30 @@ void concurrentObtainCapacityTest() throws InterruptedException {
 		executorService.awaitTermination(5, TimeUnit.SECONDS);
 
 		//capacity limit test
-		assertThat(getRegistryLocks(registry)).hasSize(CAPACITY_CNT);
+		assertThat(getRegistryLocks(registry)).hasSize(capacityCnt);
 
 		registry.expireUnusedOlderThan(-1000);
 		assertThat(getRegistryLocks(registry)).isEmpty();
 	}
 
 	@Test
 	void concurrentObtainRemoveOrderTest() throws InterruptedException {
-		final int THREAD_CNT = 2;
-		final int DUMMY_LOCK_CNT = 3;
-
-		final int CAPACITY_CNT = THREAD_CNT;
+		final int threadCnt = 2;
+		final int dummyLockCnt = 3;
 
-		final CountDownLatch countDownLatch = new CountDownLatch(THREAD_CNT);
-		registry.setCacheCapacity(CAPACITY_CNT);
-		final ExecutorService executorService = Executors.newFixedThreadPool(THREAD_CNT);
+		final CountDownLatch countDownLatch = new CountDownLatch(threadCnt);
+		registry.setCacheCapacity(threadCnt);
+		final ExecutorService executorService = Executors.newFixedThreadPool(threadCnt);
 		final Queue<String> remainLockCheckQueue = new LinkedBlockingQueue<>();
 
 		//Removed due to capcity limit
-		for (int i = 0; i < DUMMY_LOCK_CNT; i++) {
+		for (int i = 0; i < dummyLockCnt; i++) {
 			Lock obtainLock0 = registry.obtain("foo:" + i);
 			obtainLock0.lock();
 			obtainLock0.unlock();
 		}
 
-		for (int i = DUMMY_LOCK_CNT; i < THREAD_CNT + DUMMY_LOCK_CNT; i++) {
+		for (int i = dummyLockCnt; i < threadCnt + dummyLockCnt; i++) {
 			int finalI = i;
 			executorService.submit(() -> {
 				countDownLatch.countDown();
@@ -476,24 +476,24 @@ void concurrentObtainRemoveOrderTest() throws InterruptedException {
 		executorService.awaitTermination(5, TimeUnit.SECONDS);
 
 		assertThat(getRegistryLocks(registry)).containsKeys(
-				remainLockCheckQueue.toArray(new String[remainLockCheckQueue.size()]));
+				remainLockCheckQueue.toArray(new String[0]));
 	}
 
 	@Test
 	void concurrentObtainAccessRemoveOrderTest() throws InterruptedException {
-		final int THREAD_CNT = 2;
-		final int DUMMY_LOCK_CNT = 3;
+		final int threadCnt = 2;
+		final int dummyLockCnt = 3;
 
-		final int CAPACITY_CNT = THREAD_CNT + 1;
+		final int CAPACITY_CNT = threadCnt + 1;
 		final String REMAIN_DUMMY_LOCK_KEY = "foo:1";
 
-		final CountDownLatch countDownLatch = new CountDownLatch(THREAD_CNT);
+		final CountDownLatch countDownLatch = new CountDownLatch(threadCnt);
 		registry.setCacheCapacity(CAPACITY_CNT);
-		final ExecutorService executorService = Executors.newFixedThreadPool(THREAD_CNT);
+		final ExecutorService executorService = Executors.newFixedThreadPool(threadCnt);
 		final Queue<String> remainLockCheckQueue = new LinkedBlockingQueue<>();
 
 		//Removed due to capcity limit
-		for (int i = 0; i < DUMMY_LOCK_CNT; i++) {
+		for (int i = 0; i < dummyLockCnt; i++) {
 			Lock obtainLock0 = registry.obtain("foo:" + i);
 			obtainLock0.lock();
 			obtainLock0.unlock();
@@ -504,7 +504,7 @@ void concurrentObtainAccessRemoveOrderTest() throws InterruptedException {
 		obtainLock0.unlock();
 		remainLockCheckQueue.offer(toUUID(REMAIN_DUMMY_LOCK_KEY));
 
-		for (int i = DUMMY_LOCK_CNT; i < THREAD_CNT + DUMMY_LOCK_CNT; i++) {
+		for (int i = dummyLockCnt; i < threadCnt + dummyLockCnt; i++) {
 			int finalI = i;
 			executorService.submit(() -> {
 				countDownLatch.countDown();
@@ -531,15 +531,15 @@ void concurrentObtainAccessRemoveOrderTest() throws InterruptedException {
 
 	@Test
 	void setCapacityTest() {
-		final int CAPACITY_CNT = 4;
-		registry.setCacheCapacity(CAPACITY_CNT);
+		final int capacityCnt = 4;
+		registry.setCacheCapacity(capacityCnt);
 
 		registry.obtain("foo:1");
 		registry.obtain("foo:2");
 		registry.obtain("foo:3");
 
 		//capacity 4->3
-		registry.setCacheCapacity(CAPACITY_CNT - 1);
+		registry.setCacheCapacity(capacityCnt - 1);
 
 		registry.obtain("foo:4");
 
@@ -549,7 +549,7 @@ void setCapacityTest() {
 				toUUID("foo:4"));
 
 		//capacity 3->4
-		registry.setCacheCapacity(CAPACITY_CNT);
+		registry.setCacheCapacity(capacityCnt);
 		registry.obtain("foo:5");
 		assertThat(getRegistryLocks(registry)).hasSize(4);
 		assertThat(getRegistryLocks(registry)).containsKeys(toUUID("foo:3"),
@@ -588,7 +588,7 @@ void testUnlockAfterLockStatusHasBeenExpiredAndLockHasBeenAcquiredByAnotherProce
 		Lock lock2 = process2Registry.obtain("foo");
 
 		lock1.lock();
-		Thread.sleep(ttl);
+		Thread.sleep(ttl.toMillis());
 		assertThat(lock2.tryLock()).isTrue();
 
 		assertThatExceptionOfType(ConcurrentModificationException.class)

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

@@ -99,7 +99,8 @@
  * @since 4.0
  *
  */
-public final class RedisLockRegistry implements ExpirableLockRegistry<DistributedLock>, DisposableBean, RenewableLockRegistry<DistributedLock> {
+public final class RedisLockRegistry
+		implements ExpirableLockRegistry<DistributedLock>, DisposableBean, RenewableLockRegistry<DistributedLock> {
 
 	private static final Log LOGGER = LogFactory.getLog(RedisLockRegistry.class);
 
@@ -423,7 +424,8 @@ public long getLockedAt() {
 		 * @throws InterruptedException –
 		 * if the current thread is interrupted while acquiring the lock (and interruption of lock acquisition is supported)
 		 */
-		protected abstract boolean tryRedisLockInner(long time, long expireAfter) throws ExecutionException, InterruptedException;
+		protected abstract boolean tryRedisLockInner(long time, long expireAfter)
+				throws ExecutionException, InterruptedException;
 
 		/**
 		 * Unlock the lock using the unlink method in redis.
@@ -533,7 +535,8 @@ private boolean tryRedisLock(long time, long expireAfter) throws ExecutionExcept
 				if (RedisLockRegistry.this.renewalTaskScheduler != null) {
 					Duration delay = Duration.ofMillis(expireAfter / 3);
 					this.renewFuture =
-							RedisLockRegistry.this.renewalTaskScheduler.scheduleWithFixedDelay(() -> this.renew(expireAfter), delay);
+							RedisLockRegistry.this.renewalTaskScheduler.scheduleWithFixedDelay(() ->
+									this.renew(expireAfter), delay);
 				}
 			}
 			return acquired;
@@ -718,7 +721,8 @@ private RedisPubSubLock(String path) {
 		}
 
 		@Override
-		protected boolean tryRedisLockInner(long time, long expireAfter) throws ExecutionException, InterruptedException {
+		protected boolean tryRedisLockInner(long time, long expireAfter)
+				throws ExecutionException, InterruptedException {
 			return subscribeLock(time, expireAfter);
 		}