You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@artemis.apache.org by jb...@apache.org on 2026/10/06 12:11:54 UTC

(artemis) branch main updated: ARTEMIS-6285 Use JDK version of ConcurrentHashSet

This is an automated email from the ASF dual-hosted git repository.

jbertram pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/artemis.git


The following commit(s) were added to refs/heads/main by this push:
     new d0c2b17624 ARTEMIS-6285 Use JDK version of ConcurrentHashSet
d0c2b17624 is described below

commit d0c2b176247fb1616f760a7aa70c8a07aff11855
Author: Alexey Markevich <bu...@gmail.com>
AuthorDate: Tue Oct 6 10:39:56 2026 +0200

    ARTEMIS-6285 Use JDK version of ConcurrentHashSet
---
 .../activemq/artemis/cli/process/ProcessBuilder.java |  6 +++---
 .../artemis/core/server/NetworkHealthCheck.java      |  8 ++++----
 .../artemis/utils/collections/ConcurrentHashSet.java |  1 +
 .../artemis/utils/collections/ConcurrentSet.java     |  1 +
 .../artemis/utils/critical/CriticalAnalyzerImpl.java |  5 +++--
 .../FluentPropertyBeanIntrospectorWithIgnores.java   |  5 +++--
 .../core/client/impl/ClientSessionFactoryImpl.java   | 11 +++++------
 .../artemis/util/TimeAndCounterIDGeneratorTest.java  |  5 +++--
 .../artemis/jms/client/ActiveMQConnection.java       |  6 +++---
 .../artemis/jms/client/ThreadAwareContext.java       |  5 ++---
 .../artemis/core/journal/impl/JournalImpl.java       |  5 +++--
 .../amqp/connect/bridge/AMQPBridgeManagers.java      |  4 ++--
 .../AMQPFederationAddressBindingsConsumer.java       |  4 ++--
 .../protocol/amqp/proton/AMQPConnectionContext.java  |  3 +--
 .../core/protocol/openwire/OpenWireConnection.java   |  3 +--
 .../artemis/ra/ActiveMQRAConnectionManager.java      |  7 ++++---
 .../artemis/ra/ActiveMQRAManagedConnection.java      |  8 +++-----
 .../artemis/ra/recovery/RecoveryManager.java         |  6 +++---
 .../artemis/core/paging/impl/PagingManagerImpl.java  |  3 +--
 .../core/security/impl/SecurityStoreImpl.java        | 20 ++++++++++----------
 .../artemis/core/server/cluster/ClusterManager.java  |  4 ++--
 .../server/group/impl/RemoteGroupingHandler.java     |  4 ++--
 .../artemis/core/server/impl/ActiveMQServerImpl.java | 11 +++++------
 .../activemq/artemis/core/server/impl/QueueImpl.java |  4 ++--
 .../management/impl/ManagementServiceImpl.java       |  6 +++---
 .../settings/impl/HierarchicalObjectRepository.java  |  3 +--
 .../server/group/impl/ClusteredResetMockTest.java    |  4 ++--
 .../stomp/util/AbstractStompClientConnection.java    |  5 +++--
 .../tests/integration/client/ConsumerTest.java       |  4 ++--
 .../tests/integration/client/SlowConsumerTest.java   | 16 ++++++++--------
 .../OpenWireSharedStoreFailoverSmokeTest.java        |  5 +++--
 .../tests/soak/paging/ValidatePageTXTest.java        |  7 ++++---
 .../unit/core/journal/impl/BatchCommitTest.java      |  5 +++--
 33 files changed, 98 insertions(+), 96 deletions(-)

diff --git a/artemis-cli/src/main/java/org/apache/activemq/artemis/cli/process/ProcessBuilder.java b/artemis-cli/src/main/java/org/apache/activemq/artemis/cli/process/ProcessBuilder.java
index 303c956701..7eea206276 100644
--- a/artemis-cli/src/main/java/org/apache/activemq/artemis/cli/process/ProcessBuilder.java
+++ b/artemis-cli/src/main/java/org/apache/activemq/artemis/cli/process/ProcessBuilder.java
@@ -21,12 +21,12 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class ProcessBuilder {
 
-   static ConcurrentHashSet<Process> processes = new ConcurrentHashSet<>();
+   static Set<Process> processes = ConcurrentHashMap.newKeySet();
 
    static {
       Runtime.getRuntime().addShutdownHook(new Thread(() -> {
diff --git a/artemis-commons/src/main/java/org/apache/activemq/artemis/core/server/NetworkHealthCheck.java b/artemis-commons/src/main/java/org/apache/activemq/artemis/core/server/NetworkHealthCheck.java
index d31ef9fcc0..25074879e4 100644
--- a/artemis-commons/src/main/java/org/apache/activemq/artemis/core/server/NetworkHealthCheck.java
+++ b/artemis-commons/src/main/java/org/apache/activemq/artemis/core/server/NetworkHealthCheck.java
@@ -27,12 +27,12 @@ import java.net.URL;
 import java.net.URLConnection;
 import java.security.PrivilegedAction;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 
 import org.apache.activemq.artemis.logs.ActiveMQUtilLogger;
 import org.apache.activemq.artemis.utils.ActiveMQThreadFactory;
 import org.apache.activemq.artemis.utils.Env;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.sm.SecurityManagerShim;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -46,9 +46,9 @@ public class NetworkHealthCheck extends ActiveMQScheduledComponent {
 
    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
-   private final Set<ActiveMQComponent> componentList = new ConcurrentHashSet<>();
-   private final Set<String> addresses = new ConcurrentHashSet<>();
-   private final Set<URL> urls = new ConcurrentHashSet<>();
+   private final Set<ActiveMQComponent> componentList = ConcurrentHashMap.newKeySet();
+   private final Set<String> addresses = ConcurrentHashMap.newKeySet();
+   private final Set<URL> urls = ConcurrentHashMap.newKeySet();
    private NetworkInterface networkInterface;
 
    public static final String IPV6_DEFAULT_COMMAND = Env.isWindowsOs() ? "ping -n 1 -w %d000 %s" : "ping6 -c 1 %2$s";
diff --git a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentHashSet.java b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentHashSet.java
index 93b0b809dd..663225199c 100644
--- a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentHashSet.java
+++ b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentHashSet.java
@@ -26,6 +26,7 @@ import java.util.concurrent.ConcurrentMap;
  * <p>
  * Offers same concurrency as ConcurrentHashMap but for a Set
  */
+@Deprecated(forRemoval = true)
 public class ConcurrentHashSet<E> extends AbstractSet<E> implements ConcurrentSet<E> {
 
    private final ConcurrentMap<E, Object> theMap;
diff --git a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentSet.java b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentSet.java
index bab7aa3747..3ff6f6f74a 100644
--- a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentSet.java
+++ b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/collections/ConcurrentSet.java
@@ -23,6 +23,7 @@ import java.util.Set;
  *
  * @param <E> The generic class
  */
+@Deprecated(forRemoval = true)
 public interface ConcurrentSet<E> extends Set<E> {
 
    boolean addIfAbsent(E o);
diff --git a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/critical/CriticalAnalyzerImpl.java b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/critical/CriticalAnalyzerImpl.java
index a825fe8949..d6563f8f5c 100644
--- a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/critical/CriticalAnalyzerImpl.java
+++ b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/critical/CriticalAnalyzerImpl.java
@@ -19,12 +19,13 @@ package org.apache.activemq.artemis.utils.critical;
 import java.security.PrivilegedAction;
 import java.util.ConcurrentModificationException;
 import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.TimeUnit;
 
 import org.apache.activemq.artemis.core.server.ActiveMQScheduledComponent;
 import org.apache.activemq.artemis.utils.ActiveMQThreadFactory;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.sm.SecurityManagerShim;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -79,7 +80,7 @@ public class CriticalAnalyzerImpl implements CriticalAnalyzer {
 
    private List<CriticalAction> actions = new CopyOnWriteArrayList<>();
 
-   private final ConcurrentHashSet<CriticalComponent> components = new ConcurrentHashSet<>();
+   private final Set<CriticalComponent> components = ConcurrentHashMap.newKeySet();
 
    @Override
    public int getNumberOfComponents() {
diff --git a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/uri/FluentPropertyBeanIntrospectorWithIgnores.java b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/uri/FluentPropertyBeanIntrospectorWithIgnores.java
index 31ff14d378..7729a48e92 100644
--- a/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/uri/FluentPropertyBeanIntrospectorWithIgnores.java
+++ b/artemis-commons/src/main/java/org/apache/activemq/artemis/utils/uri/FluentPropertyBeanIntrospectorWithIgnores.java
@@ -21,9 +21,10 @@ import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Method;
 import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.activemq.artemis.api.core.Pair;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.commons.beanutils.FluentPropertyBeanIntrospector;
 import org.apache.commons.beanutils.IntrospectionContext;
 import org.slf4j.Logger;
@@ -34,7 +35,7 @@ public class FluentPropertyBeanIntrospectorWithIgnores extends FluentPropertyBea
 
    static Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
-   private static ConcurrentHashSet<Pair<String, String>> ignores = new ConcurrentHashSet<>();
+   private static Set<Pair<String, String>> ignores = ConcurrentHashMap.newKeySet();
 
    public static void addIgnore(String className, String methodName) {
       logger.trace("Adding ignore on {}/{}", className, methodName);
diff --git a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/ClientSessionFactoryImpl.java b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/ClientSessionFactoryImpl.java
index 999fe90456..967fac057e 100644
--- a/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/ClientSessionFactoryImpl.java
+++ b/artemis-core-client/src/main/java/org/apache/activemq/artemis/core/client/impl/ClientSessionFactoryImpl.java
@@ -20,10 +20,10 @@ import java.lang.invoke.MethodHandles;
 import java.lang.ref.WeakReference;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Future;
@@ -73,7 +73,6 @@ import org.apache.activemq.artemis.utils.PasswordMaskingUtil;
 import org.apache.activemq.artemis.utils.UUIDGenerator;
 import org.apache.activemq.artemis.utils.actors.ArtemisExecutor;
 import org.apache.activemq.artemis.utils.actors.OrderedExecutorFactory;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.sm.SecurityManagerShim;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -104,7 +103,7 @@ public class ClientSessionFactoryImpl implements ClientSessionFactoryInternal, C
 
    private final long connectionTTL;
 
-   private final Set<ClientSessionInternal> sessions = new ConcurrentHashSet<>();
+   private final Set<ClientSessionInternal> sessions = ConcurrentHashMap.newKeySet();
 
    private final Object createSessionLock = new Object();
 
@@ -138,9 +137,9 @@ public class ClientSessionFactoryImpl implements ClientSessionFactoryInternal, C
 
    private int failoverAttempts;
 
-   private final Set<SessionFailureListener> listeners = new ConcurrentHashSet<>();
+   private final Set<SessionFailureListener> listeners = ConcurrentHashMap.newKeySet();
 
-   private final Set<FailoverEventListener> failoverListeners = new ConcurrentHashSet<>();
+   private final Set<FailoverEventListener> failoverListeners = ConcurrentHashMap.newKeySet();
 
    private Connector connector;
 
@@ -155,7 +154,7 @@ public class ClientSessionFactoryImpl implements ClientSessionFactoryInternal, C
 
    private volatile boolean closed;
 
-   public static final Set<CloseRunnable> CLOSE_RUNNABLES = Collections.synchronizedSet(new HashSet<>());
+   public static final Set<CloseRunnable> CLOSE_RUNNABLES = ConcurrentHashMap.newKeySet();
 
    private final ConfirmationWindowWarning confirmationWindowWarning;
 
diff --git a/artemis-core-client/src/test/java/org/apache/activemq/artemis/util/TimeAndCounterIDGeneratorTest.java b/artemis-core-client/src/test/java/org/apache/activemq/artemis/util/TimeAndCounterIDGeneratorTest.java
index ee1ee28335..2925d76e76 100644
--- a/artemis-core-client/src/test/java/org/apache/activemq/artemis/util/TimeAndCounterIDGeneratorTest.java
+++ b/artemis-core-client/src/test/java/org/apache/activemq/artemis/util/TimeAndCounterIDGeneratorTest.java
@@ -20,11 +20,12 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
 import org.apache.activemq.artemis.utils.TimeAndCounterIDGenerator;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.junit.jupiter.api.Test;
 
 public class TimeAndCounterIDGeneratorTest {
@@ -66,7 +67,7 @@ public class TimeAndCounterIDGeneratorTest {
 
    @Test
    public void testCalculationOnMultiThread() throws Throwable {
-      final ConcurrentHashSet<Long> hashSet = new ConcurrentHashSet<>();
+      final Set<Long> hashSet = ConcurrentHashMap.newKeySet();
 
       final TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
 
diff --git a/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ActiveMQConnection.java b/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ActiveMQConnection.java
index dc0e2b9aed..ec835de28e 100644
--- a/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ActiveMQConnection.java
+++ b/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ActiveMQConnection.java
@@ -20,6 +20,7 @@ import java.lang.ref.WeakReference;
 import java.security.PrivilegedAction;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -55,7 +56,6 @@ import org.apache.activemq.artemis.reader.MessageUtil;
 import org.apache.activemq.artemis.utils.ActiveMQThreadFactory;
 import org.apache.activemq.artemis.utils.UUIDGenerator;
 import org.apache.activemq.artemis.utils.VersionLoader;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.sm.SecurityManagerShim;
 
 /**
@@ -82,9 +82,9 @@ public class ActiveMQConnection extends ActiveMQConnectionForContextImpl impleme
 
    private final int connectionType;
 
-   private final Set<ActiveMQSession> sessions = new ConcurrentHashSet<>();
+   private final Set<ActiveMQSession> sessions = ConcurrentHashMap.newKeySet();
 
-   private final Set<SimpleString> tempQueues = new ConcurrentHashSet<>();
+   private final Set<SimpleString> tempQueues = ConcurrentHashMap.newKeySet();
 
    private volatile boolean hasNoLocal;
 
diff --git a/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ThreadAwareContext.java b/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ThreadAwareContext.java
index de15fcbd0c..d54b44ebfd 100644
--- a/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ThreadAwareContext.java
+++ b/artemis-jms-client/src/main/java/org/apache/activemq/artemis/jms/client/ThreadAwareContext.java
@@ -18,8 +18,7 @@ package org.apache.activemq.artemis.jms.client;
 
 import javax.jms.IllegalStateException;
 import java.util.Set;
-
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Restricts what can be called on context passed in wrapped CompletionListener.
@@ -39,7 +38,7 @@ public class ThreadAwareContext {
     * Use a set because JMSContext can create more than one JMSConsumer to receive asynchronously from different
     * destinations.
     */
-   private final Set<Long> messageListenerThreads = new ConcurrentHashSet<>();
+   private final Set<Long> messageListenerThreads = ConcurrentHashMap.newKeySet();
 
    /**
     * Sets current thread to the context
diff --git a/artemis-journal/src/main/java/org/apache/activemq/artemis/core/journal/impl/JournalImpl.java b/artemis-journal/src/main/java/org/apache/activemq/artemis/core/journal/impl/JournalImpl.java
index 737638c7f0..775c687b32 100644
--- a/artemis-journal/src/main/java/org/apache/activemq/artemis/core/journal/impl/JournalImpl.java
+++ b/artemis-journal/src/main/java/org/apache/activemq/artemis/core/journal/impl/JournalImpl.java
@@ -34,6 +34,8 @@ import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionException;
@@ -87,7 +89,6 @@ import org.apache.activemq.artemis.utils.ExecutorFactory;
 import org.apache.activemq.artemis.utils.SimpleFuture;
 import org.apache.activemq.artemis.utils.SimpleFutureImpl;
 import org.apache.activemq.artemis.utils.actors.OrderedExecutorFactory;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.collections.ConcurrentLongHashMap;
 import org.apache.activemq.artemis.utils.collections.LongHashSet;
 import org.apache.activemq.artemis.utils.collections.SparseArrayLinkedList;
@@ -313,7 +314,7 @@ public class JournalImpl extends JournalBase implements TestableJournal, Journal
 
    private Executor appendExecutor = null;
 
-   private final ConcurrentHashSet<CountDownLatch> latches = new ConcurrentHashSet<>();
+   private final Set<CountDownLatch> latches = ConcurrentHashMap.newKeySet();
 
    private final ExecutorFactory providedIOThreadPool;
    protected ExecutorFactory ioExecutorFactory;
diff --git a/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/bridge/AMQPBridgeManagers.java b/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/bridge/AMQPBridgeManagers.java
index 258b20f43b..c243ee3fbf 100644
--- a/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/bridge/AMQPBridgeManagers.java
+++ b/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/bridge/AMQPBridgeManagers.java
@@ -18,11 +18,11 @@ package org.apache.activemq.artemis.protocol.amqp.connect.bridge;
 
 import java.lang.invoke.MethodHandles;
 import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
 import org.apache.activemq.artemis.api.core.ActiveMQException;
 import org.apache.activemq.artemis.core.config.amqpBrokerConnectivity.AMQPBridgeBrokerConnectionElement;
 import org.apache.activemq.artemis.protocol.amqp.connect.AMQPBrokerConnection;
 import org.apache.activemq.artemis.protocol.amqp.proton.AMQPSessionContext;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -33,7 +33,7 @@ public class AMQPBridgeManagers {
 
    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
-   private final Collection<AMQPBridgeManager> bridgeManagers = new ConcurrentHashSet<>();
+   private final Collection<AMQPBridgeManager> bridgeManagers = ConcurrentHashMap.newKeySet();
    private final AMQPBrokerConnection brokerConnection;
 
    public AMQPBridgeManagers(AMQPBrokerConnection brokerConnection) {
diff --git a/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/federation/AMQPFederationAddressBindingsConsumer.java b/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/federation/AMQPFederationAddressBindingsConsumer.java
index 7abe3021c6..681de6f1ce 100644
--- a/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/federation/AMQPFederationAddressBindingsConsumer.java
+++ b/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/connect/federation/AMQPFederationAddressBindingsConsumer.java
@@ -21,6 +21,7 @@ import java.lang.invoke.MethodHandles;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.activemq.artemis.api.core.Message;
 import org.apache.activemq.artemis.core.io.IOCallback;
@@ -34,7 +35,6 @@ import org.apache.activemq.artemis.core.transaction.Transaction;
 import org.apache.activemq.artemis.protocol.amqp.connect.federation.AMQPFederationMetrics.ConsumerMetrics;
 import org.apache.activemq.artemis.protocol.amqp.federation.FederationConsumerInfo;
 import org.apache.activemq.artemis.protocol.amqp.proton.AMQPSessionContext;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.qpid.proton.amqp.messaging.Accepted;
 import org.apache.qpid.proton.engine.Delivery;
 import org.apache.qpid.proton.engine.Receiver;
@@ -59,7 +59,7 @@ public final class AMQPFederationAddressBindingsConsumer extends AMQPFederationA
 
    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
-   private final Set<Binding> bindings = new ConcurrentHashSet<>();
+   private final Set<Binding> bindings = ConcurrentHashMap.newKeySet();
    private final PostOffice postOffice;
    private final StorageManager storageManager;
 
diff --git a/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/proton/AMQPConnectionContext.java b/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/proton/AMQPConnectionContext.java
index e785bb4ed8..fdd1716028 100644
--- a/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/proton/AMQPConnectionContext.java
+++ b/artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/proton/AMQPConnectionContext.java
@@ -64,7 +64,6 @@ import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
 import org.apache.activemq.artemis.spi.core.remoting.ReadyListener;
 import org.apache.activemq.artemis.utils.ByteUtil;
 import org.apache.activemq.artemis.utils.VersionLoader;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.qpid.proton.amqp.Symbol;
 import org.apache.qpid.proton.amqp.messaging.Source;
 import org.apache.qpid.proton.amqp.messaging.TerminusExpiryPolicy;
@@ -127,7 +126,7 @@ public class AMQPConnectionContext extends ProtonInitializable implements EventH
    private final Symbol[] desiredCapabilities;
    private final ScheduledExecutorService scheduledPool;
    private final Map<String, LinkCloseListener> linkCloseListeners = new ConcurrentHashMap<>();
-   private final Set<Consumer<AMQPConnectionContext>> remoteOpenedListeners = new ConcurrentHashSet<>();
+   private final Set<Consumer<AMQPConnectionContext>> remoteOpenedListeners = ConcurrentHashMap.newKeySet();
 
    private final Map<Session, AMQPSessionContext> sessions = new ConcurrentHashMap<>();
 
diff --git a/artemis-protocols/artemis-openwire-protocol/src/main/java/org/apache/activemq/artemis/core/protocol/openwire/OpenWireConnection.java b/artemis-protocols/artemis-openwire-protocol/src/main/java/org/apache/activemq/artemis/core/protocol/openwire/OpenWireConnection.java
index 9473d02351..3ea9e3b422 100644
--- a/artemis-protocols/artemis-openwire-protocol/src/main/java/org/apache/activemq/artemis/core/protocol/openwire/OpenWireConnection.java
+++ b/artemis-protocols/artemis-openwire-protocol/src/main/java/org/apache/activemq/artemis/core/protocol/openwire/OpenWireConnection.java
@@ -83,7 +83,6 @@ import org.apache.activemq.artemis.spi.core.protocol.ConnectionEntry;
 import org.apache.activemq.artemis.spi.core.remoting.Connection;
 import org.apache.activemq.artemis.utils.UUIDGenerator;
 import org.apache.activemq.artemis.utils.actors.ThresholdActor;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.command.ActiveMQDestination;
 import org.apache.activemq.command.ActiveMQMessage;
 import org.apache.activemq.command.ActiveMQTempQueue;
@@ -208,7 +207,7 @@ public class OpenWireConnection extends AbstractRemotingConnection implements Se
    private long maxInactivityDuration;
    private volatile ThresholdActor<Command> openWireActor;
 
-   private final Set<SimpleString> knownDestinations = new ConcurrentHashSet<>();
+   private final Set<SimpleString> knownDestinations = ConcurrentHashMap.newKeySet();
 
    private final AtomicBoolean disableTtl = new AtomicBoolean(false);
 
diff --git a/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAConnectionManager.java b/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAConnectionManager.java
index 9519ab9791..f826cb5730 100644
--- a/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAConnectionManager.java
+++ b/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAConnectionManager.java
@@ -22,13 +22,14 @@ import javax.resource.spi.ConnectionRequestInfo;
 import javax.resource.spi.ManagedConnection;
 import javax.resource.spi.ManagedConnectionFactory;
 
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.lang.invoke.MethodHandles;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * The connection manager used in non-managed environments.
@@ -42,7 +43,7 @@ public class ActiveMQRAConnectionManager implements ConnectionManager {
       logger.trace("constructor()");
    }
 
-   transient ConcurrentHashSet<ManagedConnection> connections = new ConcurrentHashSet<>();
+   transient Set<ManagedConnection> connections = ConcurrentHashMap.newKeySet();
 
    /**
     * Allocates a connection
@@ -81,6 +82,6 @@ public class ActiveMQRAConnectionManager implements ConnectionManager {
     */
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
       in.defaultReadObject();
-      connections = new ConcurrentHashSet<>();
+      connections = ConcurrentHashMap.newKeySet();
    }
 }
diff --git a/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAManagedConnection.java b/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAManagedConnection.java
index 761525aa71..4de691db71 100644
--- a/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAManagedConnection.java
+++ b/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/ActiveMQRAManagedConnection.java
@@ -39,10 +39,10 @@ import java.lang.invoke.MethodHandles;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
@@ -73,9 +73,9 @@ public final class ActiveMQRAManagedConnection implements ManagedConnection, Exc
 
    private final AtomicBoolean isDestroyed = new AtomicBoolean(false);
 
-   private final List<ConnectionEventListener> eventListeners;
+   private final List<ConnectionEventListener> eventListeners = Collections.synchronizedList(new ArrayList<>());
 
-   private final Set<ActiveMQRASession> handles;
+   private final Set<ActiveMQRASession> handles = ConcurrentHashMap.newKeySet();
 
    private ReentrantLock lock = new ReentrantLock();
 
@@ -111,8 +111,6 @@ public final class ActiveMQRAManagedConnection implements ManagedConnection, Exc
       this.ra = ra;
       this.userName = userName;
       this.password = password;
-      eventListeners = Collections.synchronizedList(new ArrayList<>());
-      handles = Collections.synchronizedSet(new HashSet<>());
 
       connection = null;
       nonXAsession = null;
diff --git a/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/recovery/RecoveryManager.java b/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/recovery/RecoveryManager.java
index 8bb19f9d08..a77a89ecd2 100644
--- a/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/recovery/RecoveryManager.java
+++ b/artemis-ra/src/main/java/org/apache/activemq/artemis/ra/recovery/RecoveryManager.java
@@ -23,12 +23,12 @@ import java.lang.invoke.MethodHandles;
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
 import org.apache.activemq.artemis.service.extensions.xa.recovery.ActiveMQRegistry;
 import org.apache.activemq.artemis.service.extensions.xa.recovery.ActiveMQRegistryImpl;
 import org.apache.activemq.artemis.service.extensions.xa.recovery.XARecoveryConfig;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -42,7 +42,7 @@ public final class RecoveryManager implements Serializable {
 
    private static final String RESOURCE_RECOVERY_CLASS_NAMES = "org.jboss.as.messaging.jms.AS7RecoveryRegistry;" + "org.jboss.as.integration.activemq.recovery.AS5RecoveryRegistry";
 
-   private transient Set<XARecoveryConfig> resources = new ConcurrentHashSet<>();
+   private transient Set<XARecoveryConfig> resources = ConcurrentHashMap.newKeySet();
 
    public void start(final boolean useAutoRecovery) {
       if (useAutoRecovery) {
@@ -116,6 +116,6 @@ public final class RecoveryManager implements Serializable {
     */
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
       in.defaultReadObject();
-      resources = new ConcurrentHashSet<>();
+      resources = ConcurrentHashMap.newKeySet();
    }
 }
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/paging/impl/PagingManagerImpl.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/paging/impl/PagingManagerImpl.java
index 4ce1cb3b3f..ffe64841a3 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/paging/impl/PagingManagerImpl.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/paging/impl/PagingManagerImpl.java
@@ -51,7 +51,6 @@ import org.apache.activemq.artemis.core.settings.impl.AddressSettings;
 import org.apache.activemq.artemis.utils.ByteUtil;
 import org.apache.activemq.artemis.utils.CompositeAddress;
 import org.apache.activemq.artemis.utils.SizeAwareMetric;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.runnables.AtomicRunnable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -76,7 +75,7 @@ public final class PagingManagerImpl implements PagingManager {
     */
    private final ReentrantReadWriteLock syncLock = new ReentrantReadWriteLock();
 
-   private final Set<PagingStore> blockedStored = new ConcurrentHashSet<>();
+   private final Set<PagingStore> blockedStored = ConcurrentHashMap.newKeySet();
 
    private final ConcurrentMap<SimpleString, PagingStore> stores = new ConcurrentHashMap<>();
 
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/security/impl/SecurityStoreImpl.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/security/impl/SecurityStoreImpl.java
index 3370faca3c..090ba5776e 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/security/impl/SecurityStoreImpl.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/security/impl/SecurityStoreImpl.java
@@ -26,6 +26,7 @@ import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 import java.util.stream.Collectors;
+import java.util.concurrent.ConcurrentHashMap;
 
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
@@ -58,7 +59,6 @@ import org.apache.activemq.artemis.spi.core.security.jaas.UserPrincipal;
 import org.apache.activemq.artemis.utils.ByteUtil;
 import org.apache.activemq.artemis.utils.CertificateUtil;
 import org.apache.activemq.artemis.utils.CompositeAddress;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.collections.TypedProperties;
 import org.apache.activemq.artemis.utils.sm.SecurityManagerShim;
 import org.slf4j.Logger;
@@ -81,7 +81,7 @@ public class SecurityStoreImpl implements SecurityStore, HierarchicalRepositoryC
 
    private final ActiveMQSecurityManager securityManager;
 
-   private final Cache<String, ConcurrentHashSet<SimpleString>> authorizationCache;
+   private final Cache<String, Set<SimpleString>> authorizationCache;
 
    private final Cache<String, Pair<Boolean, Subject>> authenticationCache;
 
@@ -357,13 +357,13 @@ public class SecurityStoreImpl implements SecurityStore, HierarchicalRepositoryC
 
          if (validated && user != null) {
             // if we get here we're granted, add to the cache
-            ConcurrentHashSet<SimpleString> set;
+            final Set<SimpleString> set;
             String key = createAuthorizationCacheKey(user, checkType);
-            ConcurrentHashSet<SimpleString> act = getAuthorizationCacheEntry(key);
+            Set<SimpleString> act = getAuthorizationCacheEntry(key);
             if (act != null) {
                set = act;
             } else {
-               set = new ConcurrentHashSet<>();
+               set = ConcurrentHashMap.newKeySet();
                putAuthorizationCacheEntry(set, key);
             }
             set.add(Objects.requireNonNullElse(fqqn, bareAddress));
@@ -566,18 +566,18 @@ public class SecurityStoreImpl implements SecurityStore, HierarchicalRepositoryC
       }
    }
 
-   private void putAuthorizationCacheEntry(ConcurrentHashSet<SimpleString> value, String key) {
+   private void putAuthorizationCacheEntry(Set<SimpleString> value, String key) {
       if (authorizationCache != null) {
          authorizationCache.put(key, value);
          logger.trace("Put into authz cache; key: {}; value: {}", key, value);
       }
    }
 
-   private ConcurrentHashSet<SimpleString> getAuthorizationCacheEntry(String key) {
+   private Set<SimpleString> getAuthorizationCacheEntry(String key) {
       if (authorizationCache == null) {
          return null;
       } else {
-         ConcurrentHashSet<SimpleString> value = authorizationCache.getIfPresent(key);
+         Set<SimpleString> value = authorizationCache.getIfPresent(key);
          logger.trace("Get from authz cache; key: {}; value: {}", key, value);
          return value;
       }
@@ -616,7 +616,7 @@ public class SecurityStoreImpl implements SecurityStore, HierarchicalRepositoryC
    private boolean checkAuthorizationCache(final SimpleString dest, final String user, final CheckType checkType) {
       boolean granted = false;
 
-      ConcurrentHashSet<SimpleString> act = getAuthorizationCacheEntry(createAuthorizationCacheKey(user, checkType));
+      Set<SimpleString> act = getAuthorizationCacheEntry(createAuthorizationCacheKey(user, checkType));
       if (act != null) {
          granted = act.contains(dest);
       }
@@ -671,7 +671,7 @@ public class SecurityStoreImpl implements SecurityStore, HierarchicalRepositoryC
       return authenticationCache;
    }
 
-   public Cache<String, ConcurrentHashSet<SimpleString>> getAuthorizationCache() {
+   public Cache<String, Set<SimpleString>> getAuthorizationCache() {
       return authorizationCache;
    }
 
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/cluster/ClusterManager.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/cluster/ClusterManager.java
index ecac84215b..91dfd672ae 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/cluster/ClusterManager.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/cluster/ClusterManager.java
@@ -27,6 +27,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ScheduledExecutorService;
 
@@ -65,7 +66,6 @@ import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
 import org.apache.activemq.artemis.spi.core.remoting.Acceptor;
 import org.apache.activemq.artemis.utils.ExecutorFactory;
 import org.apache.activemq.artemis.utils.FutureLatch;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import java.lang.invoke.MethodHandles;
@@ -145,7 +145,7 @@ public class ClusterManager implements ActiveMQComponent {
    // the cluster connections which links this node to other cluster nodes
    private final Map<String, ClusterConnection> clusterConnections = new HashMap<>();
 
-   private final Set<ServerLocatorInternal> clusterLocators = new ConcurrentHashSet<>();
+   private final Set<ServerLocatorInternal> clusterLocators = ConcurrentHashMap.newKeySet();
 
    private final Executor executor;
 
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/group/impl/RemoteGroupingHandler.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/group/impl/RemoteGroupingHandler.java
index 99216c4d78..b7d2d0c27b 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/group/impl/RemoteGroupingHandler.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/group/impl/RemoteGroupingHandler.java
@@ -19,6 +19,7 @@ package org.apache.activemq.artemis.core.server.group.impl;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.TimeUnit;
@@ -35,7 +36,6 @@ import org.apache.activemq.artemis.core.server.ActiveMQServerLogger;
 import org.apache.activemq.artemis.core.server.management.ManagementService;
 import org.apache.activemq.artemis.core.server.management.Notification;
 import org.apache.activemq.artemis.utils.ExecutorFactory;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.collections.TypedProperties;
 
 /**
@@ -60,7 +60,7 @@ public final class RemoteGroupingHandler extends GroupHandlingAbstract {
 
    private final ConcurrentMap<SimpleString, List<SimpleString>> groupMap = new ConcurrentHashMap<>();
 
-   private final ConcurrentHashSet<Notification> pendingNotifications = new ConcurrentHashSet<>();
+   private final Set<Notification> pendingNotifications = ConcurrentHashMap.newKeySet();
 
    private boolean started = false;
 
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ActiveMQServerImpl.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ActiveMQServerImpl.java
index 6d95de2fb8..0154a605ac 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ActiveMQServerImpl.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/ActiveMQServerImpl.java
@@ -217,7 +217,6 @@ import org.apache.activemq.artemis.utils.TimeUtils;
 import org.apache.activemq.artemis.utils.UUID;
 import org.apache.activemq.artemis.utils.VersionLoader;
 import org.apache.activemq.artemis.utils.actors.OrderedExecutorFactory;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.critical.CriticalAction;
 import org.apache.activemq.artemis.utils.critical.CriticalAnalyzer;
 import org.apache.activemq.artemis.utils.critical.CriticalAnalyzerImpl;
@@ -365,15 +364,15 @@ public class ActiveMQServerImpl implements ActiveMQServer {
 
    private final Map<String, BrokerConnection> brokerConnectionMap = new ConcurrentHashMap<>();
 
-   private final Set<ActivateCallback> activateCallbacks = new ConcurrentHashSet<>();
+   private final Set<ActivateCallback> activateCallbacks = ConcurrentHashMap.newKeySet();
 
-   private final Set<ActivationFailureListener> activationFailureListeners = new ConcurrentHashSet<>();
+   private final Set<ActivationFailureListener> activationFailureListeners = ConcurrentHashMap.newKeySet();
 
-   private final Set<IOCriticalErrorListener> ioCriticalErrorListeners = new ConcurrentHashSet<>();
+   private final Set<IOCriticalErrorListener> ioCriticalErrorListeners = ConcurrentHashMap.newKeySet();
 
-   private final Set<PostQueueCreationCallback> postQueueCreationCallbacks = new ConcurrentHashSet<>();
+   private final Set<PostQueueCreationCallback> postQueueCreationCallbacks = ConcurrentHashMap.newKeySet();
 
-   private final Set<PostQueueDeletionCallback> postQueueDeletionCallbacks = new ConcurrentHashSet<>();
+   private final Set<PostQueueDeletionCallback> postQueueDeletionCallbacks = ConcurrentHashMap.newKeySet();
 
    private volatile GroupingHandler groupingHandler;
 
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/QueueImpl.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/QueueImpl.java
index 0e867595e2..5b18c3a9b5 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/QueueImpl.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/impl/QueueImpl.java
@@ -32,6 +32,7 @@ import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Random;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
@@ -117,7 +118,6 @@ import org.apache.activemq.artemis.utils.ReferenceCounter;
 import org.apache.activemq.artemis.utils.ReusableLatch;
 import org.apache.activemq.artemis.utils.SizeAwareMetric;
 import org.apache.activemq.artemis.utils.actors.ArtemisExecutor;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.collections.LinkedListIterator;
 import org.apache.activemq.artemis.utils.collections.NodeStoreFactory;
 import org.apache.activemq.artemis.utils.collections.PriorityLinkedList;
@@ -342,7 +342,7 @@ public class QueueImpl extends CriticalComponentImpl implements Queue {
     */
    private final Object directDeliveryGuard = new Object();
 
-   private final ConcurrentHashSet<String> lingerSessionIds = new ConcurrentHashSet<>();
+   private final Set<String> lingerSessionIds = ConcurrentHashMap.newKeySet();
 
    public String debug() {
       StringWriter str = new StringWriter();
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/management/impl/ManagementServiceImpl.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/management/impl/ManagementServiceImpl.java
index af6222480f..65981610b3 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/management/impl/ManagementServiceImpl.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/server/management/impl/ManagementServiceImpl.java
@@ -30,6 +30,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.function.Predicate;
 import java.util.regex.Pattern;
@@ -115,7 +116,6 @@ import org.apache.activemq.artemis.core.settings.HierarchicalRepository;
 import org.apache.activemq.artemis.core.settings.impl.AddressSettings;
 import org.apache.activemq.artemis.core.transaction.ResourceManager;
 import org.apache.activemq.artemis.spi.core.remoting.Acceptor;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.artemis.utils.collections.TypedProperties;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -162,7 +162,7 @@ public class ManagementServiceImpl implements ManagementService {
 
    private boolean notificationsEnabled;
 
-   private final Set<NotificationListener> listeners = new ConcurrentHashSet<>();
+   private final Set<NotificationListener> listeners = ConcurrentHashMap.newKeySet();
 
    private final ObjectNameBuilder objectNameBuilder;
 
@@ -170,7 +170,7 @@ public class ManagementServiceImpl implements ManagementService {
 
    private final Pattern viewPermissionMatcher;
 
-   private final Set<ObjectName> registeredNames = new ConcurrentHashSet<>();
+   private final Set<ObjectName> registeredNames = ConcurrentHashMap.newKeySet();
 
    public ManagementServiceImpl(final MBeanServer mbeanServer, final Configuration configuration) {
       this.mbeanServer = mbeanServer;
diff --git a/artemis-server/src/main/java/org/apache/activemq/artemis/core/settings/impl/HierarchicalObjectRepository.java b/artemis-server/src/main/java/org/apache/activemq/artemis/core/settings/impl/HierarchicalObjectRepository.java
index be6737f272..0ca275983e 100644
--- a/artemis-server/src/main/java/org/apache/activemq/artemis/core/settings/impl/HierarchicalObjectRepository.java
+++ b/artemis-server/src/main/java/org/apache/activemq/artemis/core/settings/impl/HierarchicalObjectRepository.java
@@ -38,7 +38,6 @@ import org.apache.activemq.artemis.core.settings.HierarchicalRepository;
 import org.apache.activemq.artemis.core.settings.HierarchicalRepositoryChangeListener;
 import org.apache.activemq.artemis.core.settings.Mergeable;
 import org.apache.activemq.artemis.utils.CompositeAddress;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -106,7 +105,7 @@ public class HierarchicalObjectRepository<T> implements HierarchicalRepository<T
    /**
     * any registered listeners, these get fired on changes to the repository
     */
-   private final ConcurrentHashSet<HierarchicalRepositoryChangeListener> listeners = new ConcurrentHashSet<>();
+   private final Set<HierarchicalRepositoryChangeListener> listeners = ConcurrentHashMap.newKeySet();
 
    public HierarchicalObjectRepository() {
       this(null);
diff --git a/artemis-server/src/test/java/org/apache/activemq/artemis/core/server/group/impl/ClusteredResetMockTest.java b/artemis-server/src/test/java/org/apache/activemq/artemis/core/server/group/impl/ClusteredResetMockTest.java
index 2858ddb278..953524bf89 100644
--- a/artemis-server/src/test/java/org/apache/activemq/artemis/core/server/group/impl/ClusteredResetMockTest.java
+++ b/artemis-server/src/test/java/org/apache/activemq/artemis/core/server/group/impl/ClusteredResetMockTest.java
@@ -21,6 +21,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Predicate;
@@ -79,7 +80,6 @@ import org.apache.activemq.artemis.core.transaction.ResourceManager;
 import org.apache.activemq.artemis.spi.core.remoting.Acceptor;
 import org.apache.activemq.artemis.tests.util.ServerTestBase;
 import org.apache.activemq.artemis.utils.ReusableLatch;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -190,7 +190,7 @@ public class ClusteredResetMockTest extends ServerTestBase {
 
    class FakeManagement implements ManagementService {
 
-      public ConcurrentHashSet<Notification> pendingNotifications = new ConcurrentHashSet<>();
+      public Set<Notification> pendingNotifications = ConcurrentHashMap.newKeySet();
 
       final ReusableLatch latch;
 
diff --git a/tests/artemis-test-support/src/main/java/org/apache/activemq/artemis/tests/integration/stomp/util/AbstractStompClientConnection.java b/tests/artemis-test-support/src/main/java/org/apache/activemq/artemis/tests/integration/stomp/util/AbstractStompClientConnection.java
index cf6d129205..21f859b700 100644
--- a/tests/artemis-test-support/src/main/java/org/apache/activemq/artemis/tests/integration/stomp/util/AbstractStompClientConnection.java
+++ b/tests/artemis-test-support/src/main/java/org/apache/activemq/artemis/tests/integration/stomp/util/AbstractStompClientConnection.java
@@ -23,7 +23,9 @@ import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
 
@@ -31,7 +33,6 @@ import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import org.apache.activemq.artemis.core.protocol.stomp.Stomp;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.activemq.transport.netty.NettyTransport;
 import org.apache.activemq.transport.netty.NettyTransportFactory;
 import org.apache.activemq.transport.netty.NettyTransportListener;
@@ -54,7 +55,7 @@ public abstract class AbstractStompClientConnection implements StompClientConnec
    //protected ReaderThread readerThread;
    protected String scheme;
 
-   private static final ConcurrentHashSet<StompClientConnection> connections = new ConcurrentHashSet<>();
+   private static final Set<StompClientConnection> connections = ConcurrentHashMap.newKeySet();
 
 
    public static final void tearDownConnections() {
diff --git a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/ConsumerTest.java b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/ConsumerTest.java
index 6bfceb33b6..e2d6c3d118 100644
--- a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/ConsumerTest.java
+++ b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/ConsumerTest.java
@@ -36,6 +36,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Set;
 import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.TimeUnit;
@@ -71,7 +72,6 @@ import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
 import org.apache.activemq.artemis.tests.util.ActiveMQTestBase;
 import org.apache.activemq.artemis.tests.util.Wait;
 import org.apache.activemq.artemis.utils.ByteUtil;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.apache.qpid.jms.JmsConnectionFactory;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.TestTemplate;
@@ -913,7 +913,7 @@ public class ConsumerTest extends ActiveMQTestBase {
    @TestTemplate
    public void testReceiveAndResend() throws Exception {
 
-      final Set<Object> sessions = new ConcurrentHashSet<>();
+      final Set<Object> sessions = ConcurrentHashMap.newKeySet();
       final AtomicInteger errors = new AtomicInteger(0);
 
       final SimpleString QUEUE_RESPONSE = SimpleString.of("QUEUE_RESPONSE");
diff --git a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/SlowConsumerTest.java b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/SlowConsumerTest.java
index 9b934ea074..a0d2d5b8a2 100644
--- a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/SlowConsumerTest.java
+++ b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/client/SlowConsumerTest.java
@@ -18,6 +18,7 @@ package org.apache.activemq.artemis.tests.integration.client;
 
 import java.lang.invoke.MethodHandles;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
@@ -46,7 +47,6 @@ import org.apache.activemq.artemis.core.settings.impl.SlowConsumerThresholdMeasu
 import org.apache.activemq.artemis.tests.util.ActiveMQTestBase;
 import org.apache.activemq.artemis.tests.util.Wait;
 import org.apache.activemq.artemis.utils.RandomUtil;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
@@ -454,7 +454,7 @@ public class SlowConsumerTest extends ActiveMQTestBase {
       session.commit();
 
 
-      ConcurrentHashSet<ClientMessage> receivedMessages = new ConcurrentHashSet<>();
+      Set<ClientMessage> receivedMessages = ConcurrentHashMap.newKeySet();
       FixedRateConsumer consumer = new FixedRateConsumer(40, MESSAGES_PER_MINUTE, receivedMessages, sf, QUEUE, 0);
       consumer.start();
 
@@ -496,7 +496,7 @@ public class SlowConsumerTest extends ActiveMQTestBase {
       session.commit();
 
 
-      ConcurrentHashSet<ClientMessage> receivedMessages = new ConcurrentHashSet<>();
+      Set<ClientMessage> receivedMessages = ConcurrentHashMap.newKeySet();
       FixedRateConsumer consumer = new FixedRateConsumer(30, MESSAGES_PER_MINUTE, receivedMessages, sf, QUEUE, 0);
       consumer.start();
 
@@ -548,7 +548,7 @@ public class SlowConsumerTest extends ActiveMQTestBase {
       session.commit();
 
 
-      ConcurrentHashSet<ClientMessage> receivedMessages = new ConcurrentHashSet<>();
+      Set<ClientMessage> receivedMessages = ConcurrentHashMap.newKeySet();
       FixedRateConsumer consumer = new FixedRateConsumer(30, MESSAGES_PER_MINUTE, receivedMessages, sf, QUEUE, 0);
       consumer.start();
 
@@ -589,7 +589,7 @@ public class SlowConsumerTest extends ActiveMQTestBase {
       session.commit();
 
 
-      ConcurrentHashSet<ClientMessage> receivedMessages = new ConcurrentHashSet<>();
+      Set<ClientMessage> receivedMessages = ConcurrentHashMap.newKeySet();
       FixedRateConsumer consumer = new FixedRateConsumer(70, MESSAGES_PER_MINUTE, receivedMessages, sf, QUEUE, 0);
       consumer.start();
 
@@ -634,7 +634,7 @@ public class SlowConsumerTest extends ActiveMQTestBase {
       session.commit();
 
 
-      ConcurrentHashSet<ClientMessage> receivedMessages = new ConcurrentHashSet<>();
+      Set<ClientMessage> receivedMessages = ConcurrentHashMap.newKeySet();
       FixedRateConsumer consumer = new FixedRateConsumer(80, MESSAGES_PER_MINUTE, receivedMessages, sf, QUEUE, 0);
       consumer.start();
 
@@ -707,8 +707,8 @@ public class SlowConsumerTest extends ActiveMQTestBase {
 
       FixedRateProducer producer = new FixedRateProducer(threshold * 2, MESSAGES_PER_SECOND, sf1, QUEUE, messages);
 
-      final Set<FixedRateConsumer> consumers = new ConcurrentHashSet<>();
-      final Set<ClientMessage> receivedMessages = new ConcurrentHashSet<>();
+      final Set<FixedRateConsumer> consumers = ConcurrentHashMap.newKeySet();
+      final Set<ClientMessage> receivedMessages = ConcurrentHashMap.newKeySet();
 
       consumers.add(new FixedRateConsumer(threshold, MESSAGES_PER_SECOND, receivedMessages, sf2, QUEUE, 1));
       consumers.add(new FixedRateConsumer(threshold, MESSAGES_PER_SECOND, receivedMessages, sf3, QUEUE, 2));
diff --git a/tests/smoke-tests/src/test/java/org/apache/activemq/artemis/tests/smoke/failover/OpenWireSharedStoreFailoverSmokeTest.java b/tests/smoke-tests/src/test/java/org/apache/activemq/artemis/tests/smoke/failover/OpenWireSharedStoreFailoverSmokeTest.java
index 79d202c8b7..842ca80e72 100644
--- a/tests/smoke-tests/src/test/java/org/apache/activemq/artemis/tests/smoke/failover/OpenWireSharedStoreFailoverSmokeTest.java
+++ b/tests/smoke-tests/src/test/java/org/apache/activemq/artemis/tests/smoke/failover/OpenWireSharedStoreFailoverSmokeTest.java
@@ -24,6 +24,8 @@ import javax.jms.Session;
 import javax.jms.TextMessage;
 import java.io.File;
 import java.lang.invoke.MethodHandles;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.ExecutorService;
@@ -37,7 +39,6 @@ import org.apache.activemq.artemis.tests.smoke.common.SmokeTestBase;
 import org.apache.activemq.artemis.tests.util.CFUtil;
 import org.apache.activemq.artemis.util.ServerUtil;
 import org.apache.activemq.artemis.utils.Wait;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -127,7 +128,7 @@ public class OpenWireSharedStoreFailoverSmokeTest extends SmokeTestBase {
 
       CyclicBarrier startFlag = new CyclicBarrier(PRODUCERS);
 
-      ConcurrentHashSet<String> duplicateIDs = new ConcurrentHashSet<>();
+      Set<String> duplicateIDs = ConcurrentHashMap.newKeySet();
 
       for (int producerID = 0; producerID < PRODUCERS; producerID++) {
          final int theProducerID = producerID;
diff --git a/tests/soak-tests/src/test/java/org/apache/activemq/artemis/tests/soak/paging/ValidatePageTXTest.java b/tests/soak-tests/src/test/java/org/apache/activemq/artemis/tests/soak/paging/ValidatePageTXTest.java
index 49e701bdaa..42d4d50af7 100644
--- a/tests/soak-tests/src/test/java/org/apache/activemq/artemis/tests/soak/paging/ValidatePageTXTest.java
+++ b/tests/soak-tests/src/test/java/org/apache/activemq/artemis/tests/soak/paging/ValidatePageTXTest.java
@@ -29,6 +29,8 @@ import javax.transaction.xa.XAResource;
 import javax.transaction.xa.Xid;
 import java.io.File;
 import java.lang.invoke.MethodHandles;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.ExecutorService;
@@ -41,7 +43,6 @@ import org.apache.activemq.artemis.api.core.ActiveMQDuplicateIdException;
 import org.apache.activemq.artemis.cli.commands.helper.HelperCreate;
 import org.apache.activemq.artemis.tests.soak.SoakTestBase;
 import org.apache.activemq.artemis.tests.util.CFUtil;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
@@ -119,7 +120,7 @@ public class ValidatePageTXTest extends SoakTestBase {
 
       AtomicInteger sequenceGenerator = new AtomicInteger(1);
 
-      ConcurrentHashSet<String> dupList = new ConcurrentHashSet<>();
+      Set<String> dupList = ConcurrentHashMap.newKeySet();
 
       CountDownLatch enoughSent = new CountDownLatch(SEND_GROUPS * GROUP_SIZE * 2);
       CountDownLatch latchDone = new CountDownLatch(SEND_GROUPS * GROUP_SIZE);
@@ -258,7 +259,7 @@ public class ValidatePageTXTest extends SoakTestBase {
                        AtomicInteger sequenceGenerator,
                        AtomicBoolean running,
                        String messageBody,
-                       ConcurrentHashSet<String> dupList,
+                       Set<String> dupList,
                        CountDownLatch enoughSent,
                        CountDownLatch latchDone) {
       try {
diff --git a/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/journal/impl/BatchCommitTest.java b/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/journal/impl/BatchCommitTest.java
index 9c5bafbeb8..4ec0afabe4 100644
--- a/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/journal/impl/BatchCommitTest.java
+++ b/tests/unit-tests/src/test/java/org/apache/activemq/artemis/tests/unit/core/journal/impl/BatchCommitTest.java
@@ -25,6 +25,8 @@ import java.lang.invoke.MethodHandles;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -47,7 +49,6 @@ import org.apache.activemq.artemis.tests.util.ActiveMQTestBase;
 import org.apache.activemq.artemis.utils.ExecutorFactory;
 import org.apache.activemq.artemis.utils.SimpleIDGenerator;
 import org.apache.activemq.artemis.utils.actors.OrderedExecutorFactory;
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
@@ -99,7 +100,7 @@ public class BatchCommitTest extends ActiveMQTestBase {
 
       CountDownLatch latch = new CountDownLatch(RECORDS);
 
-      ConcurrentHashSet<Long> existingRecords = new ConcurrentHashSet<>();
+      Set<Long> existingRecords = ConcurrentHashMap.newKeySet();
 
       AtomicInteger errors = new AtomicInteger(0);
 


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@artemis.apache.org
For additional commands, e-mail: commits-help@artemis.apache.org