Fix potential double acquisition in SingleLock

`SingleLock` uses a `ForkJoinPool.ManagedBlocker` for efficient blocking
in a fork-join pool. In the `isReleasable()` method it calls `tryLock()`
without remembering the outcome. The `block` method also unconditionally
called `lockInterruptibly()` even if the lock was already acquired.
The problem that can arise is that the lock is acquired multiple times,
but only released once.

`CompositeLockManagedBlocker` is also updated, so that `block()` checks
for `acquired` before locking.

documentation/src/docs/asciidoc/release-notes/release-notes-5.11.1.adoc

@@ -20,6 +20,8 @@ JUnit repository on GitHub.
   the store is queried via one of the `get(...)` or `getOrComputeIfAbsent(...)` methods;
   however, if a `getOrComputeIfAbsent(...)` invocation results in the computation of a new
   value, an exception will still be thrown.
+* Fix potential locking issue with `ExclusiveResource` in the `HierarchicalTestExecutorService`.
+  This could lead to deadlocks in certain scenarios.
 
 [[release-notes-5.11.1-junit-platform-deprecations-and-breaking-changes]]
 ==== Deprecations and Breaking Changes

junit-platform-engine/src/main/java/org/junit/platform/engine/support/hierarchical/CompositeLock.java

@@ -68,8 +68,10 @@ private class CompositeLockManagedBlocker implements ForkJoinPool.ManagedBlocker
 
 		@Override
 		public boolean block() throws InterruptedException {
-			acquireAllLocks();
-			acquired = true;
+			if (!acquired) {
+				acquireAllLocks();
+				acquired = true;
+			}
 			return true;
 		}
 

junit-platform-engine/src/main/java/org/junit/platform/engine/support/hierarchical/SingleLock.java

@@ -46,14 +46,16 @@ private class SingleLockManagedBlocker implements ForkJoinPool.ManagedBlocker {
 
 		@Override
 		public boolean block() throws InterruptedException {
-			lock.lockInterruptibly();
-			acquired = true;
+			if (!acquired) {
+				lock.lockInterruptibly();
+				acquired = true;
+			}
 			return true;
 		}
 
 		@Override
 		public boolean isReleasable() {
-			return acquired || lock.tryLock();
+			return acquired || (acquired = lock.tryLock());
 		}
 
 	}