[performance] Avoid O(n^2) in DeadlockDetector.lockAcquired()

With n conflicting rules. "conflicting.contains(possible)" Has been
observed as severe hotspot in workspace with n= ~1000 projects

Functionality is tested with
IJobManagerTest.testTransferToJobWaitingOnChildRule()

Author: Jörg Kubitz

runtime/bundles/org.eclipse.core.jobs/src/org/eclipse/core/internal/jobs/DeadlockDetector.java

@@ -16,6 +16,8 @@
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
 import org.eclipse.core.internal.runtime.RuntimeLog;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IStatus;
@@ -304,14 +306,13 @@ void lockAcquired(Thread owner, ISchedulingRule lock) {
 		 * or conflict with a lock the given lock will acquire implicitly
 		 * (locks are acquired implicitly when a conflicting lock is acquired)
 		 */
-		ArrayList<ISchedulingRule> conflicting = new ArrayList<>(1);
+		Collection<ISchedulingRule> conflicting = new HashSet<>(1);
 		//only need two passes through all the locks to pick up all conflicting rules
 		int NUM_PASSES = 2;
 		conflicting.add(lock);
 		graph[threadIndex][lockIndex]++;
 		for (int i = 0; i < NUM_PASSES; i++) {
-			for (int k = 0; k < conflicting.size(); k++) {
-				ISchedulingRule current = conflicting.get(k);
+			for (ISchedulingRule current : conflicting) {
 				for (int j = 0; j < locks.size(); j++) {
 					ISchedulingRule possible = locks.get(j);
 					if (!conflicting.contains(possible) && current.isConflicting(possible)) {