Vertx verlangsamt mit mehreren Datei-Upload-Anfragen

Question

Ich versuche, einen großen Dateiserver (2 Millionen gleichzeitig) zu erstellen und nach vielen Suchen fand ich heraus, dass Vertx am besten für solche Aufgaben ist. So kam ich mit diesem Stück Code bis

public void uploadFile(Vertx vertx,RoutingContext ctx,String targetFilePath,FileUploadListener mListener) { 
     ctx.request().pause(); 

     new File(targetFilePath).getParentFile().mkdirs(); 

      vertx.fileSystem().open(targetFilePath, new OpenOptions(), new Handler<AsyncResult<AsyncFile>>() { 

      @Override 
      public void handle(AsyncResult<AsyncFile> arg0) { 
       try { 
        AsyncFile file = arg0.result(); 
        if(file == null) { 
         Logger.Log("file null"); 
         mListener.onFail(); 
         return; 
        } 
        Pump pump = Pump.pump(ctx.request(), file); 

        ctx.request().endHandler(v1 -> file.close(v2 -> { 
           mListener.onSuccess(new File(targetFilePath)); 
        })); 
        pump.start(); 
        ctx.request().resume(); 

       }catch (Exception e) { 
        e.printStackTrace(); 
        Logger.Log(e); 
        mListener.onFail(); 
        return; 
       } 
      } 
     }); 
    } 

, wie immer, wenn mehrere Anforderungen versuchen, eine Datei mit dieser Methode (dauert 1 Sekunde für eine 9mb Datei, aber dauert nur 1 Minute für 100 von 9mb Dateien) gleichzeitig laden die Upload-Prozess verlangsamt. Gibt es etwas, das fehlt für die Verbesserung der Gleichzeitigkeit oder seit ich dies auf Windows 10 ausführen, hat eine Steckdose eine solche Geschwindigkeitsbegrenzung? Dank

hier ist mein MainVerticle

public class MainDeployment extends AbstractVerticle{ 


private Router router = Router.router(vertx); 

    @Override 
    public void start() throws Exception { 

     //GUI.display("Sub Verticle Has Deployed"); 

    // Different ways of deploying verticles 

    // Deploy a verticle and don't wait for it to start 

    for(Entry<String, MyHttpHandler> entry : MyVertxServer.map.entrySet()){ 
     router.route(entry.getKey()).handler(new Handler<RoutingContext>() { 

      @Override 
      public void handle(RoutingContext ctx) { 
       System.out.println(ctx.request().uri()); 

       String[] handlerID = ctx.request().uri().split(ctx.currentRoute().getPath()); 

       String suffix = handlerID.length > 1 ? handlerID[1] : null; 
       entry.getValue().Handle(ctx, new VertxUtils(), suffix); 

      } 
     }); 
    } 

    MyVertxServer.server.requestHandler(router::accept); 

    } 

} 

Answer 1

Sie Code sieht gut aus. Ihre Testmethoden sind nicht. Das hat eigentlich nichts mit Vertex zu tun. Wenn Sie zum ersten Mal von demselben Computer aus hochladen, den Sie zum Herunterladen verwenden (Vertx aus seiner Perspektive lädt Dateien herunter, die Sie hochladen), wird die Menge der für Vertex verfügbaren Ressourcen um die Hälfte reduziert. Du hast was, 4 CPUs, wahrscheinlich? 2 von ihnen werden mit dem Hochladen beschäftigt sein, und nur zwei andere werden Ihre Anfragen bedienen.

Dann gibt es das Netzwerk. Eigentlich bin ich erstaunt, dass Sie in der Lage sind 9Mb in einer Sekunde hochzuladen. Das ist ein ernsthaftes Netzwerk dort.

Und natürlich gibt es HDD. Ich hoffe für dein Experiment, dass du eine Datei hochlädst, die du zwischengespeichert hast. Andernfalls haben Sie jetzt 100 Prozesse, die diese Datei immer wieder lesen, während andere 100 versuchen, sie zu schreiben. Selbst wenn Sie erstklassige SSDs haben, ist das eine ziemliche Herausforderung.

Also, nachdem Sie all das gesagt haben, müssen Sie jetzt die Mathematik machen. Stellen Sie Ihren Code zunächst auf einem anderen Computer als Ihrem Client bereit.