下面的代码运行良好，它连接到给定的服务器（主机，端口）并获取连接状态。
它的功能是：
1. PollService 实现了 Callable 接口，连接到服务器（主机，端口），然后返回状态。
2. 由于这应该定期发生，它在一个 while(true) 循环中迭代 Hashmap 条目。
问题：在服务器端，我发现它需要2到3秒才能到达线程，如果我使用带有定期实现的 Runnable，它将在1秒内连接。看起来无限迭代 Hashmap 是一种缓慢的方法。
然而，我不能使用 Runnable，因为它不会返回我后面需要使用的连接状态。
下面是连接到服务器的 ServiceMonitor 类（客户端）。
    package org.example;
    
    import java.time.LocalDateTime;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    import java.util.stream.Collectors;
    
    public class ServicesMonitor {
      private ExecutorService scheduledExecutorService = null;
      private static Logger logger = Logger.getLogger(ServicesMonitor.class.getName());
      private final Map<ServiceType, List<ClientMonitorService>> clientMonitorServicesMap = new HashMap<>();
    
      public void registerInterest(ClientMonitorService clientMonitorService) {
        clientMonitorServicesMap.computeIfAbsent(clientMonitorService.getServiceToMonitor().getServiceType(), v -> new ArrayList<>()).add(clientMonitorService);
      }
    
      public Map<ServiceType, List<ClientMonitorService>> getClientMonitorService() {
        return clientMonitorServicesMap;
      }
    
      public void poll(){
        //Observable.interval(1, TimeUnit.SECONDS).st
      }
      public void pollServices() {
        scheduledExecutorService = Executors.newFixedThreadPool(clientMonitorServicesMap.size());
        try {
    
          while (true) {
            clientMonitorServicesMap.forEach((k, v) -> {
              Future<Boolean> val = scheduledExecutorService.submit(new PollService(k));
              try {
                boolean result = val.get();
                System.out.println("service " + k.getHost() + ":" + k.getPort() + " status is " + result);
                if (result) {
                  List<ClientMonitorService> list = v.stream().filter(a -> LocalDateTime.now().getSecond() % a.getServiceToMonitor().getFreqSec() == 0)
                          .collect(Collectors.toList());
                  list.stream().forEach(a -> System.out.println(a.getClientId()));
                }
    
              } catch (InterruptedException e) {
                e.printStackTrace();
              } catch (ExecutionException e) {
                e.printStackTrace();
              }
    
            });
          }
        } catch (Exception e) {
          logger.log(Level.SEVERE, e.getMessage());
        } finally {
          scheduledExecutorService.shutdown();
        }
      }
    }

while (true) {
    clientMonitorServicesMap.forEach((k, v) -> {
        Future<Boolean> val = scheduledExecutorService.submit(new PollService(k));
        try {
            boolean result = val.get(1, TimeUnit.SECONDS);
            System.out.println("service " + k.getHost() + ":" + k.getPort() + " status is " + result);
            if (result) {
                List<ClientMonitorService> list = v.stream()
                        //.filter(a -> LocalDateTime.now().getSecond() % a.getServiceToMonitor().getFreqSec() == 0)
                        .collect(Collectors.toList());
                list.stream().forEach(a -> System.out.println(a.getClientId()));
            }
        } catch (InterruptedException e) {
            logger.log(Level.WARNING, "Interrupted -> " + k.getHost() + ":" + k.getPort());
        } catch (ExecutionException e) {
            logger.log(Level.INFO, "ExecutionException exception -> " + k.getHost() + ":" + k.getPort());
        } catch (TimeoutException e) {
            logger.log(Level.INFO, "TimeoutException exception -> " + k.getHost() + ":" + k.getPort());
        }
    });
}