Java 增加线程数时的高延迟

在下面的代码中，DataGather=endDataGather-beginDataGather需要1.7ms &服务响应时间=服务完成-服务请求发送 从20us到200us不等（因为它们在同一局域网上是模拟的虚拟对象，所以很低） 现在，如果我将tomcat8线程从10增加到200，数据收集增加到150ms+，即使我将线程从200增加到1000，它甚至会增加250+。机器规格为8芯氙气，64gb ram。当apache基准以-n40000-c100参数运行时，会测量时间，这是由于线程调度/上下文切换还是其他原因？如何消除这种变异？当真正的服务出现时，延迟时间为20-100毫秒，它还会继续存在吗

       public List<ServiceResponse> getData(final List<Service> services, final Data data) {
          //beginDateGather;

          final List<ServiceResponse> serviceResponses = Collections.synchronizedList(new ArrayList<>());
          try {
            final CountDownLatch latch = new CountDownLatch(services.size());
            Map<Future<HttpResponse>, HttpRequestBase> responseRequestMap = new HashMap<Future<HttpResponse>, HttpRequestBase>();

            for (final service service : services) {
              //creating request for a service
              try {
                HttpRequestBase request = RequestCreator.getRequestBase(service, data);
                //service_REQUEST_SENT
                Future<HttpResponse> response = client.execute(request,
                    new MyFutureCallback(service, data, latch, serviceResponses));
                responseRequestMap.put(response, request);
              } catch (Exception e) {
                latch.countDown();
              }
            }
            try {
              boolean isWaitIsOver = latch.await(timeout, TimeUnit.MILLISECONDS);
              if (!isWaitIsOver) {
                for (Future<HttpResponse> response : responseRequestMap.keySet()) {
                  if (!response.isDone()) {
                    response.cancel(true);
                  }
                }
              }
            } catch (InterruptedException e) {
            }
          } catch (Exception e) {
          }
          //endDataGather
          return serviceResponses;
    }


     public class MyFutureCallback implements FutureCallback<HttpResponse> {

        private Service service;
        private Data data;
        private CountDownLatch latch;
        private List<serviceResponse> serviceResponses;

        public MyFutureCallback( Service service, Data data, CountDownLatch latch, List<ServiceResponse> serviceResponses) {
          this.service = service;
          this.data = data;
          this.latch = latch;
          this.serviceResponses = serviceResponses;
        }

        @Override
        public void completed(HttpResponse result) {
          try {
            ServiceResponse serviceResponse = parseResponse(result, data, service);
              serviceResponses.add(serviceResponse);
          } catch (Exception e) {
          } finally {
            //service_COMPLETED
            latch.countDown();
          }
        }

        @Override
        public void failed(Exception ex) {
          latch.countDown();
        }

        @Override
        public void cancelled() {
          latch.countDown();
        }
       }

public List getData（最终列表服务，最终数据）{
//开始收集；
最终列表serviceResponses=Collections.synchronizedList（新的ArrayList（））；
试一试{
final CountDownLatch latch=新的CountDownLatch（services.size（））；
Map responseRequestMap=new HashMap（）；
用于（最终服务：服务）{
//创建服务请求
试一试{
HttpRequestBase request=RequestCreator.getRequestBase（服务，数据）；
//服务请求已发送
未来响应=client.execute（请求，
新的MyFutureCallback（服务、数据、锁存、服务响应）；
responseRequestMap.put（响应、请求）；
}捕获（例外e）{
倒计时（）；
}
}
试一试{
布尔值isWaitIsOver=latch.await（超时，时间单位为毫秒）；
如果（！isWaitIsOver）{
for（未来响应：responseRequestMap.keySet（））{
如果（！response.isDone（））{
响应。取消（true）；
}
}
}
}捕捉（中断异常e）{
}
}捕获（例外e）{
}
//endDataGather
返回服务响应；
}
公共类MyFutureCallback实现FutureCallback{
私人服务；
私人数据；
私人倒计时闩锁；
私有列表服务响应；
公共MyFutureCallback（服务服务、数据数据、CountDownLatch闩锁、列表服务响应）{
服务=服务；
这个数据=数据；
this.latch=闩锁；
this.serviceResponses=serviceResponses；
}
@凌驾
公共无效已完成（HttpResponse结果）{
试一试{
ServiceResponse ServiceResponse=parseResponse（结果、数据、服务）；
serviceResponse.add（serviceResponse）；
}捕获（例外e）{
}最后{
//服务完成
倒计时（）；
}
}
@凌驾
公共作废失败（例外情况除外）{
倒计时（）；
}
@凌驾
公众假期取消（）{
倒计时（）；
}
}

是的，这似乎是由于线程的上下文切换。 在这种情况下，增加线程数没有帮助。 您可以使用线程池进行回调。 请检查此链接以供参考，并尝试使用.PoolgClientAsyncConnectionManager