Java ConcurrentMap.isEmpty方法代码示例

import java.util.concurrent.ConcurrentMap; //导入方法依赖的package包/类
private boolean offsetBehindMuchThanData(final String topic, ConcurrentMap<Integer, Long> table) {
    Iterator<Entry<Integer, Long>> it = table.entrySet().iterator();
    boolean result = !table.isEmpty();

    while (it.hasNext() && result) {
        Entry<Integer, Long> next = it.next();
        long minOffsetInStore = this.brokerController.getMessageStore().getMinOffsetInQueue(topic, next.getKey());
        long offsetInPersist = next.getValue();
        result = offsetInPersist <= minOffsetInStore;
    }

    return result;
}
 

import java.util.concurrent.ConcurrentMap; //导入方法依赖的package包/类
public void scanNotActiveChannel() {
    Iterator<Entry<String, ConsumerGroupInfo>> it = this.consumerTable.entrySet().iterator();
    while (it.hasNext()) {
        Entry<String, ConsumerGroupInfo> next = it.next();
        String group = next.getKey();
        ConsumerGroupInfo consumerGroupInfo = next.getValue();
        ConcurrentMap<Channel, ClientChannelInfo> channelInfoTable =
            consumerGroupInfo.getChannelInfoTable();

        Iterator<Entry<Channel, ClientChannelInfo>> itChannel = channelInfoTable.entrySet().iterator();
        while (itChannel.hasNext()) {
            Entry<Channel, ClientChannelInfo> nextChannel = itChannel.next();
            ClientChannelInfo clientChannelInfo = nextChannel.getValue();
            long diff = System.currentTimeMillis() - clientChannelInfo.getLastUpdateTimestamp();
            if (diff > CHANNEL_EXPIRED_TIMEOUT) {
                log.warn(
                    "SCAN: remove expired channel from ConsumerManager consumerTable. channel={}, consumerGroup={}",
                    RemotingHelper.parseChannelRemoteAddr(clientChannelInfo.getChannel()), group);
                RemotingUtil.closeChannel(clientChannelInfo.getChannel());
                itChannel.remove();
            }
        }

        if (channelInfoTable.isEmpty()) {
            log.warn(
                "SCAN: remove expired channel from ConsumerManager consumerTable, all clear, consumerGroup={}",
                group);
            it.remove();
        }
    }
}
 

import java.util.concurrent.ConcurrentMap; //导入方法依赖的package包/类
private static ConcurrentMap<ServerType, List<Class<?>>> getMergedAgents(
        final ServerType category,
        final ConcurrentMap<ServerType, Class<?>> internals
) {
    final ConcurrentMap<ServerType, List<Class<?>>> agents = ZeroAnno.getAgents();
    if (agents.isEmpty()) {
        // Inject ServerType by category input.
        agents.put(category, new ArrayList<>(internals.values()));
    }
    return agents;
}
 

import java.util.concurrent.ConcurrentMap; //导入方法依赖的package包/类
@Override
protected void serviceStop() throws Exception {
  System.out.println("Called stooppppp");
  super.serviceStop();
  isStopped = true;
  ConcurrentMap<ApplicationId, Application> applications =
      getNMContext().getApplications();
  // ensure that applications are empty
  if(!applications.isEmpty()) {
    assertionFailedInThread.set(true);
  }
  syncBarrier.await(10000, TimeUnit.MILLISECONDS);
}
 

import java.util.concurrent.ConcurrentMap; //导入方法依赖的package包/类
public void cleanExpiredConsumerQueue() {
    // CommitLog的最小Offset
    long minCommitLogOffset = this.commitLog.getMinOffset();

    Iterator<Entry<String, ConcurrentMap<Integer, ConsumeQueue>>> it = this.consumeQueueTable.entrySet().iterator();
    while (it.hasNext()) {
        Entry<String, ConcurrentMap<Integer, ConsumeQueue>> next = it.next();
        String topic = next.getKey();
        if (!topic.equals(ScheduleMessageService.SCHEDULE_TOPIC)) {
            ConcurrentMap<Integer, ConsumeQueue> queueTable = next.getValue();
            Iterator<Entry<Integer, ConsumeQueue>> itQT = queueTable.entrySet().iterator();
            while (itQT.hasNext()) {
                Entry<Integer, ConsumeQueue> nextQT = itQT.next();
                long maxCLOffsetInConsumeQueue = nextQT.getValue().getLastOffset();

                // maxCLOffsetInConsumeQueue==-1有可能正好是索引文件刚好创建的那一时刻,此时不清除数据
                if (maxCLOffsetInConsumeQueue == -1) {
                    log.warn("maybe ConsumeQueue was created just now. topic={} queueId={} maxPhysicOffset={} minLogicOffset={}.", //
                        nextQT.getValue().getTopic(), //
                        nextQT.getValue().getQueueId(), //
                        nextQT.getValue().getMaxPhysicOffset(), //
                        nextQT.getValue().getMinLogicOffset());
                } else if (maxCLOffsetInConsumeQueue < minCommitLogOffset) {
                    log.info(
                        "cleanExpiredConsumerQueue: {} {} consumer queue destroyed, minCommitLogOffset: {} maxCLOffsetInConsumeQueue: {}", //
                        topic, //
                        nextQT.getKey(), //
                        minCommitLogOffset, //
                        maxCLOffsetInConsumeQueue);

                    DefaultMessageStore.this.commitLog.removeQueueFromTopicQueueTable(nextQT.getValue().getTopic(),
                        nextQT.getValue().getQueueId());

                    nextQT.getValue().destroy();
                    itQT.remove();
                }
            }

            if (queueTable.isEmpty()) {
                log.info("cleanExpiredConsumerQueue: {},topic destroyed", topic);
                it.remove();
            }
        }
    }
}
 

import java.util.concurrent.ConcurrentMap; //导入方法依赖的package包/类
@Override
public void setConnection(Application application, String sessionId, IKey key, IWebSocketConnection connection)
{
	Args.notNull(application, "application");
	Args.notNull(sessionId, "sessionId");
	Args.notNull(key, "key");

	ConcurrentMap<String, ConcurrentMap<IKey, IWebSocketConnection>> connectionsBySession = application.getMetaData(KEY);
	if (connectionsBySession == null)
	{
		synchronized (KEY)
		{
			connectionsBySession = application.getMetaData(KEY);
			if (connectionsBySession == null)
			{
				connectionsBySession = Generics.newConcurrentHashMap();
				application.setMetaData(KEY, connectionsBySession);
			}
		}
	}

	ConcurrentMap<IKey, IWebSocketConnection> connectionsByPage = connectionsBySession.get(sessionId);
	if (connectionsByPage == null && connection != null)
	{
		connectionsByPage = connectionsBySession.get(sessionId);
		if (connectionsByPage == null)
		{
			connectionsByPage = Generics.newConcurrentHashMap();
			ConcurrentMap<IKey, IWebSocketConnection> old = connectionsBySession.putIfAbsent(sessionId, connectionsByPage);
			if (old != null)
			{
				connectionsByPage = old;
			}
		}
	}

	if (connection != null)
	{
		connectionsByPage.put(key, connection);
	}
	else if (connectionsByPage != null)
	{
		connectionsByPage.remove(key);
		if (connectionsByPage.isEmpty())
		{
			connectionsBySession.remove(sessionId);
		}
	}
}
 

import java.util.concurrent.ConcurrentMap; //导入方法依赖的package包/类
private void loadJsonInfo(ConcurrentMap<String, Set<String>> infoMap, String targetInfo)
    throws IOException, JSONException {
  synchronized (infoMap) {
    if (!infoMap.isEmpty()) {
      return;
    }

    JSONArray buildInfo = new JSONArray(
        "[" + simpleCompsBuildInfo.join(",") + "," +
        extCompsBuildInfo.join(",") + "]");

    for (int i = 0; i < buildInfo.length(); ++i) {
      JSONObject compJson = buildInfo.getJSONObject(i);
      JSONArray infoArray = null;
      String type = compJson.getString("type");
      try {
        infoArray = compJson.getJSONArray(targetInfo);
      } catch (JSONException e) {
        // Older compiled extensions will not have a broadcastReceiver
        // defined. Rather then require them all to be recompiled, we
        // treat the missing attribute as empty.
        if (e.getMessage().contains("broadcastReceiver")) {
          LOG.log(Level.INFO, "Component \"" + type + "\" does not have a broadcast receiver.");
          continue;
        } else {
          throw e;
        }
      }

      if (!simpleCompTypes.contains(type) && !extCompTypes.contains(type)) {
        continue;
      }

      Set<String> infoSet = Sets.newHashSet();
      for (int j = 0; j < infoArray.length(); ++j) {
        String info = infoArray.getString(j);
        infoSet.add(info);
      }

      if (!infoSet.isEmpty()) {
        infoMap.put(type, infoSet);
      }
    }
  }
}