How to use

ConcurrentOpenHashMap

in

com.yahoo.pulsar.common.util.collections

public List<V> values() {
  List<V> values = Lists.newArrayList();
  forEach((key, value) -> values.add(value));
  return values;
}

private static ConcurrentOpenHashMap<String, Field> prepareDynamicConfigurationMap() {
  ConcurrentOpenHashMap<String, Field> dynamicConfigurationMap = new ConcurrentOpenHashMap<>();
  for (Field field : ServiceConfiguration.class.getDeclaredFields()) {
    if (field != null && field.isAnnotationPresent(FieldContext.class)) {
      field.setAccessible(true);
      if (((FieldContext) field.getAnnotation(FieldContext.class)).dynamic()) {
        dynamicConfigurationMap.put(field.getName(), field);
      }
    }
  }
  return dynamicConfigurationMap;
}

public PersistentReplicator getPersistentReplicator(String remoteCluster) {
  return replicators.get(remoteCluster);
}

public int getNumberOfNamespaceBundles() {
  this.numberOfNamespaceBundles = 0;
  this.multiLayerTopicsMap.forEach((namespaceName, bundles) -> {
    this.numberOfNamespaceBundles += bundles.size();
  });
  return this.numberOfNamespaceBundles;
}

public List<PersistentTopic> getAllTopicsFromNamespaceBundle(String namespace, String bundle) {
  return multiLayerTopicsMap.get(namespace).get(bundle).values();
}

  private static <K, V> void insertKeyValueNoLock(Object[] table, int capacity, K key, V value) {
    int bucket = signSafeMod(hash(key), capacity);
    while (true) {
      K storedKey = (K) table[bucket];
      if (storedKey == EmptyKey) {
        // The bucket is empty, so we can use it
        table[bucket] = key;
        table[bucket + 1] = value;
        return;
      }
      bucket = (bucket + 2) & (table.length - 1);
    }
  }
}

public void removeTopicFromCache(String topic) {
  try {
    DestinationName destination = DestinationName.get(topic);
    NamespaceBundle namespaceBundle = pulsar.getNamespaceService().getBundle(destination);
    checkArgument(namespaceBundle instanceof NamespaceBundle);
    String bundleName = namespaceBundle.toString();
    String namespaceName = destination.getNamespaceObject().toString();
    synchronized (multiLayerTopicsMap) {
      ConcurrentOpenHashMap<String, ConcurrentOpenHashMap<String, PersistentTopic>> namespaceMap = multiLayerTopicsMap
          .get(namespaceName);
      ConcurrentOpenHashMap<String, PersistentTopic> bundleMap = namespaceMap.get(bundleName);
      bundleMap.remove(topic);
      if (bundleMap.isEmpty()) {
        namespaceMap.remove(bundleName);
      }
      if (namespaceMap.isEmpty()) {
        multiLayerTopicsMap.remove(namespaceName);
        final ClusterReplicationMetrics clusterReplicationMetrics = pulsarStats
            .getClusterReplicationMetrics();
        replicationClients.forEach((cluster, client) -> {
          clusterReplicationMetrics.remove(clusterReplicationMetrics.getKeyName(namespaceName, cluster));
        });
      }
    }
  } catch (Exception e) {
    log.warn("Got exception when retrieving bundle name during removeTopicFromCache", e);
  }
  topics.remove(topic);
}

final CountDownLatch allCursorsCounter = new CountDownLatch(1);
final long errorInReadingCursor = (long) -1;
ConcurrentOpenHashMap<String, Long> ledgerRetryMap = new ConcurrentOpenHashMap<>();
if (accurate && ledgerRetryMap.size() > 0) {
  ledgerRetryMap.forEach((cursorName, ledgerId) -> {
    if (log.isDebugEnabled()) {
      log.debug("Cursor {} Ledger {} Trying to obtain MD from BkAdmin", cursorName, ledgerId);

topicsMap.forEach((namespaceName, bundles) -> {
  if (bundles.isEmpty()) {
    return;
    bundles.forEach((bundle, topics) -> {
      NamespaceBundleStats currentBundleStats = bundleStats.computeIfAbsent(bundle,
          k -> new NamespaceBundleStats());
      currentBundleStats.reset();
      currentBundleStats.topics = topics.size();
      topics.forEach((name, topic) -> {
        try {
          topic.updateRates(nsStats, currentBundleStats, topicStatsStream,

public PersistentTopic(String topic, ManagedLedger ledger, BrokerService brokerService) {
  this.topic = topic;
  this.ledger = ledger;
  this.brokerService = brokerService;
  this.producers = new ConcurrentOpenHashSet<Producer>();
  this.subscriptions = new ConcurrentOpenHashMap<>();
  this.replicators = new ConcurrentOpenHashMap<>();
  this.isFenced = false;
  this.replicatorPrefix = brokerService.pulsar().getConfiguration().getReplicatorPrefix();
  USAGE_COUNT_UPDATER.set(this, 0);
  for (ManagedCursor cursor : ledger.getCursors()) {
    if (cursor.getName().startsWith(replicatorPrefix)) {
      String localCluster = brokerService.pulsar().getConfiguration().getClusterName();
      String remoteCluster = PersistentReplicator.getRemoteCluster(cursor.getName());
      replicators.put(remoteCluster,
          new PersistentReplicator(this, cursor, localCluster, remoteCluster, brokerService));
    } else {
      final String subscriptionName = Codec.decode(cursor.getName());
      subscriptions.put(subscriptionName, new PersistentSubscription(this, subscriptionName, cursor));
      // subscription-cursor gets activated by default: deactivate as there is no active subscription right
      // now
      subscriptions.get(subscriptionName).deactivateCursor();
    }
  }
  this.lastActive = System.nanoTime();
}

public V remove(K key) {
  checkNotNull(key);
  long h = hash(key);
  return getSection(h).remove(key, null, (int) h);
}

private void addTopicToStatsMaps(DestinationName topicName, PersistentTopic topic) {
  try {
    NamespaceBundle namespaceBundle = pulsar.getNamespaceService().getBundle(topicName);
    if (namespaceBundle != null) {
      synchronized (multiLayerTopicsMap) {
        String serviceUnit = namespaceBundle.toString();
        multiLayerTopicsMap //
            .computeIfAbsent(topicName.getNamespace(), k -> new ConcurrentOpenHashMap<>()) //
            .computeIfAbsent(serviceUnit, k -> new ConcurrentOpenHashMap<>()) //
            .put(topicName.toString(), topic);
      }
    }
    invalidateOfflineTopicStatCache(topicName);
  } catch (Exception e) {
    log.warn("Got exception when retrieving bundle name during create persistent topic", e);
  }
}

public CompletableFuture<Topic> getTopic(final String topic) {
  try {
    CompletableFuture<Topic> topicFuture = topics.get(topic);
    if (topicFuture != null) {
      if (topicFuture.isCompletedExceptionally()) {
        // Exceptional topics should be recreated.
        topics.remove(topic, topicFuture);
      } else {
        return topicFuture;
      }
    }
    return topics.computeIfAbsent(topic, this::createPersistentTopic);
  } catch (IllegalArgumentException e) {
    log.warn("[{}] Illegalargument exception when loading topic", topic, e);
    return failedFuture(e);
  } catch (RuntimeException e) {
    Throwable cause = e.getCause();
    if (cause instanceof ServiceUnitNotReadyException) {
      log.warn("[{}] Service unit is not ready when loading the topic", topic);
    } else {
      log.warn("[{}] Unexpected exception when loading topic: {}", topic, cause);
    }
    return failedFuture(cause);
  }
}

if (!subscriptions.isEmpty()) {
  isFenced = false;
  deleteFuture.completeExceptionally(new TopicBusyException("Topic has subscriptions"));
subscriptions.forEach((s, sub) -> futures.add(sub.delete()));

  if (!replicators.containsKey(cluster)) {
    futures.add(startReplicator(cluster));
replicators.forEach((cluster, replicator) -> {

public void remove(String namespaceCluster) {
  ReplicationMetrics replicationMetrics = metricsMap.get(namespaceCluster);
  if (replicationMetrics != null) {
    replicationMetrics.recycle();
    metricsMap.remove(namespaceCluster);
  }
}

public PulsarClient getReplicationClient(String cluster) {
  PulsarClient client = replicationClients.get(cluster);
  if (client != null) {
    return client;
  }
  return replicationClients.computeIfAbsent(cluster, key -> {
    try {
      String path = PulsarWebResource.path("clusters", cluster);
      ClusterData data = this.pulsar.getConfigurationCache().clustersCache().get(path)
          .orElseThrow(() -> new KeeperException.NoNodeException(path));
      ClientConfiguration configuration = new ClientConfiguration();
      configuration.setUseTcpNoDelay(false);
      configuration.setConnectionsPerBroker(pulsar.getConfiguration().getReplicationConnectionsPerBroker());
      configuration.setStatsInterval(0, TimeUnit.SECONDS);
      if (pulsar.getConfiguration().isAuthenticationEnabled()) {
        configuration.setAuthentication(pulsar.getConfiguration().getBrokerClientAuthenticationPlugin(),
            pulsar.getConfiguration().getBrokerClientAuthenticationParameters());
      }
      String clusterUrl = configuration.isUseTls()
          ? (isNotBlank(data.getBrokerServiceUrlTls()) ? data.getBrokerServiceUrlTls()
              : data.getServiceUrlTls())
          : null;
      clusterUrl = (isNotBlank(clusterUrl)) ? clusterUrl
          : (isNotBlank(data.getBrokerServiceUrl()) ? data.getBrokerServiceUrl() : data.getServiceUrl());
      return new PulsarClientImpl(clusterUrl, configuration, this.workerGroup);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  });
}

public ClusterReplicationMetrics(String localCluster, boolean metricsEnabled) {
  metricsList = new ArrayList<>();
  this.localCluster = localCluster;
  metricsMap = new ConcurrentOpenHashMap<>();
  this.metricsEnabled = metricsEnabled;
}

private CompletableFuture<? extends Subscription> getNonDurableSubscription(String subscriptionName, MessageId startMessageId) {
  CompletableFuture<Subscription> subscriptionFuture = new CompletableFuture<>();
  Subscription subscription = subscriptions.computeIfAbsent(subscriptionName, name -> {
    // Create a new non-durable cursor only for the first consumer that connects
    MessageIdImpl msgId = startMessageId != null ? (MessageIdImpl) startMessageId
        : (MessageIdImpl) MessageId.latest;
    Position startPosition = new PositionImpl(msgId.getLedgerId(), msgId.getEntryId());
    ManagedCursor cursor = null;
    try {
      cursor = ledger.newNonDurableCursor(startPosition);
    } catch (ManagedLedgerException e) {
      subscriptionFuture.completeExceptionally(e);
    }
    return new PersistentSubscription(this, subscriptionName, cursor);
  });
  if (!subscriptionFuture.isDone()) {
    subscriptionFuture.complete(subscription);
  } else {
    // failed to initialize managed-cursor: clean up created subscription
    subscriptions.remove(subscriptionName);
  }
  return subscriptionFuture;
}

@Override
public void openCursorComplete(ManagedCursor cursor, Object ctx) {
  if (log.isDebugEnabled()) {
    log.debug("[{}][{}] Opened cursor", topic, subscriptionName);
  }
  subscriptionFuture.complete(subscriptions.computeIfAbsent(subscriptionName,
      name -> new PersistentSubscription(PersistentTopic.this, subscriptionName, cursor)));
}