hohe Latenz auf die Erhöhung Fadenzahl

Question

Im folgenden Code DataGather = endDataGather - beginDataGather nimmt 1,7ms & Zeit für Service = service_COMPLETED zu reagieren - service_REQUEST_SENT , die von 20us bis 200 us variieren (da sie Dummy daher auf der gleichen lan verspottet so niedrig) jetzt, wenn ich tomcat8 Thread von 10 auf 200 erhöhen, erhöhen DataGather auf 150ms + und selbst wenn ich Thread von 200 bis 1000 dann erhöhen Sie sogar 250 + .Machine specs 8 Kern Xenon, 64GB RAM. Die Zeit wird gemessen, wenn der Apache-Benchmark mit -n 40000 -c 100 args läuft, liegt das an Thread-Scheduling/Kontext-Switching oder etwas anderem? Wie werde ich diese Variante los? Wird es bleiben, wenn reale Dienste mit Latenzzeiten von 20-100ms ins Bild kommen werden?

 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(); 
     } 
     } 

Answer 1

Ja scheint es aufgrund der Kontextwechsel von Threads. Das Erhöhen der Anzahl der Threads hilft in diesem Fall nicht. Sie können einen Thread-Pool für Rückrufe verwenden. diesen Link für Ihre Referenz zu prüfen und versuchen .PoolingClientAsyncConnectionManager

How to use HttpAsyncClient with multithreaded operation?